system

Abstract

Provide a system. [Solution] means for registering user profile data; A means for analyzing the ideal partner image provided by the user using natural language processing and storing the same as characteristic data; A means for calculating a compatibility score using user data and characteristic data stored in a database and generating a plurality of candidate lists; a means for notifying a user of the candidate list; and means for providing a communication means for sending and receiving messages to and from candidates selected from the candidate list.

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] Conventional matchmaking services face the problem of making it difficult for users to find their ideal partner. In particular, there is a lack of a way to automatically suggest compatible partners that take into account the specific characteristics and values ​​desired by the user, so users must go to great lengths to find a suitable partner from among many candidates. In such a situation, it takes a great deal of time and effort to find the ideal partner, and the probability of successful matching is low. [Means for solving the problem]

[0005] To solve this problem, the present invention provides the following means: a means for registering user profile data, and a means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data. It also includes a means for calculating compatibility scores and generating a list of multiple candidates using the user data and feature data saved in the database, and a means for notifying the user of the candidate list. Furthermore, by providing a communication means for sending and receiving messages between users and candidates selected from the candidate list, a system is realized that allows users to efficiently find their ideal partner.

[0006] "User" refers to a person who uses this system to find an ideal partner.

[0007] "Profile Data" refers to data that includes personal information such as a user's name, age, gender, hobbies, and values.

[0008] "Ideal partner image" refers to information including characteristics such as personality, hobbies, and values ​​of the partner the user desires.

[0009] "Natural language processing" refers to the technology of mechanically analyzing text data and understanding and processing human language.

[0010] "Characteristic data" refers to characteristic information about an ideal partner that is extracted and quantified through natural language processing.

[0011] "Database" refers to a data storage system for storing profile data and characteristic data.

[0012] "Compatibility score" refers to a compatibility score calculated based on commonalities between the user and the candidate.

[0013] "Candidate List" refers to a list of multiple partner candidates selected based on compatibility scores.

[0014] "Communication Means" refers to means that provide the functionality for sending and receiving messages between users and candidates. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0023] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0036] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. This system registers the user's profile data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a communication means for sending and receiving messages between candidates. The specific operation of this system is described below.

[0037] User Registration

[0038] Device:

[0039] When a user accesses the service and opens the homepage, a login button and a new registration button are displayed. When the user clicks the "New Registration" button, a user registration form is displayed.

[0040] User:

[0041] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values, etc.) in the form and click the "Register" button.

[0042] Device:

[0043] The entered user information is sent to the server in JSON format.

[0044] server:

[0045] The received data is temporarily stored, and characteristic keywords are extracted from the "ideal partner image" using a natural language processing engine and converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8, etc.). The user information and extracted characteristic data are then stored in a database.

[0046] Matching process

[0047] server:

[0048] Periodically, a batch job is run to retrieve all user information in the database, and then an algorithm is run to compare each user's ideal partner characteristics with the real data of all other users (e.g., personality, hobbies, values).

[0049] server:

[0050] The commonalities between each user pair are calculated as a score (e.g., if the commonalities "kindness" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on these scores, a list of the most compatible matching candidates is created for each user.

[0051] Notification of matching results

[0052] server:

[0053] Build a list of the most compatible candidates (e.g., top 5 candidates) and store it in a database. Generate matching results for each user and prepare to notify them sequentially.

[0054] Device:

[0055] Registered users are asked to log in and the matching results page is displayed. A list of matching candidates is notified to the user, and basic information (name, age, hobbies, etc.) and photos of each candidate are displayed.

[0056] Messaging Features

[0057] User:

[0058] Click the "Send a message" button for the candidate you like from the list of matching candidates, enter your message in the message input form, and click the "Send" button.

[0059] Device:

[0060] Forwards the sent message to the server.

[0061] server:

[0062] Save the message to a database and notify the receiving user that a new message has arrived (via email or in-app notification).

[0063] Device:

[0064] When the receiving user logs in, it displays new messages. It provides a chat interface for both parties to send and receive messages, and retrieves and displays the message history from the server.

[0065] (Example)

[0066] Example of user registration

[0067] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[0068] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[0069] Specific example of matching process

[0070] The server executes a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities). A score is calculated based on the commonalities, and the candidate with the highest score is selected.

[0071] Specific examples of notifications

[0072] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[0073] Messaging Examples

[0074] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[0075] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[0076] The device displays the message to Hanako and provides a reply function.

[0077] The processing flow will be explained below.

[0078] Program processing steps

[0079] Step 1: User Registration

[0080] 1. Device:

[0081] Display the homepage and display the login and new registration buttons.

[0082] When the user clicks the "New Registration" button, a user registration form is displayed.

[0083] 2. User:

[0084] Enter your name, age, gender, email address, and ideal partner (personality, hobbies, values, etc.) in the user registration form.

[0085] Click the "Register" button.

[0086] 3. Terminal:

[0087] The entered user information is converted to JSON format and sent to the server.

[0088] 4. Server:

[0089] Temporarily saves received data.

[0090] The natural language processing engine analyzes the "ideal partner image" and extracts characteristic keywords.

[0091] The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8).

[0092] Store user information and feature data in a database.

[0093] Step 2: Matching

[0094] 1. Server:

[0095] Periodically run a batch job to retrieve all user information in the database.

[0096] The characteristics of each user's ideal partner are compared with the actual data of all other users.

[0097] 2. Server:

[0098] The commonality between each user pair is calculated as a score (e.g., if the commonality "kindness" = 0.9 and the commonality "likes movies" = 0.8, the total score = 1.7).

[0099] Based on the calculated score, a list of compatible candidates is generated for each user.

[0100] Step 3: Notification of match results

[0101] 1. Server:

[0102] Build a list of the most compatible candidates (e.g., top 5).

[0103] Prepare and store matching result data for each user.

[0104] 2. Terminal:

[0105] When a user logs in, a matching results page will be displayed.

[0106] The user is notified of a list of matching candidates and basic information and photos of each candidate are displayed.

[0107] Step 4: Messaging Features

[0108] 1. User:

[0109] Click the "Send Message" button for the candidate you like from the list of matching candidates.

[0110] Enter your message in the message input form and click the "Send" button.

[0111] 2. Terminal:

[0112] Forwards the sent message to the server.

[0113] 3. Server:

[0114] Save the message in the database.

[0115] Notify the receiving user that a new message has arrived (via email or in-app notification).

[0116] 4. Terminal:

[0117] Displays new messages when the receiving user logs in.

[0118] It provides a chat interface for both parties to send messages to each other.

[0119] Retrieve and display message history from the server.

[0120] Specific examples

[0121] Step 1 example

[0122] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[0123] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[0124] Step 2: Example

[0125] The server runs a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities).

[0126] A score is calculated based on commonalities, and the candidate with the highest score is selected.

[0127] Step 3 example

[0128] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[0129] Step 4: Example

[0130] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[0131] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[0132] The device displays the message to Hanako and provides a reply function.

[0133] Example 1

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

[0135] Conventional matching systems were unable to effectively analyze users' ideal partner profiles, making it difficult to accurately assess compatibility with potential partners. Furthermore, they struggled to smoothly exchange messages with potential partners, leaving a need for an improved user experience.

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

[0137] In this invention, the server includes means for registering user profile data, means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data, means for calculating compatibility scores using the user data and feature data saved in the database and generating multiple candidate lists, means for notifying the user of the candidate list, means for providing communication means for sending and receiving messages with candidates selected from the candidate list, and means for displaying the candidate list and related candidate information on a user interface, thereby enabling users to efficiently meet their ideal partner.

[0138] "User profile data" refers to data that includes personal information and attribute information provided by a user.

[0139] The "ideal partner image" is data that represents the characteristics of the user's desired partner, such as personality, appearance, hobbies, and values.

[0140] "Natural language processing" is a technology that allows computers to understand and interpret human language and extract specific information.

[0141] "Feature data" is data that quantifies the ideal partner image extracted through natural language processing.

[0142] A "database" is a system that systematically stores and manages user profile data and characteristic data.

[0143] A "compatibility score" is an evaluation index calculated based on the commonalities and similarities between the user and the candidate.

[0144] A "candidate list" is a list of multiple suitable partner candidates selected based on their compatibility scores.

[0145] "Notification" is the act of informing the user of results or information.

[0146] "Communication means" refers to the technical means by which messages are sent and received between users.

[0147] A "user interface" is a screen or operating means that allows a user to interact with a system.

[0148] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. The system registers the user's profile data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a communication means for sending and receiving messages between the users and the candidates.

[0149] User Registration

[0150] Device:

[0151] When a user accesses the service, a login button and a new registration button are displayed on the home page. When a user clicks the "New Registration" button, a user registration form is displayed.

[0152] User:

[0153] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values, etc.) in the form and click the "Register" button.

[0154] Device:

[0155] The entered user information is sent to the server in JSON format.

[0156] server:

[0157] The received data is temporarily stored, and characteristic keywords are extracted from the "ideal partner image" using a natural language processing engine and converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8, etc.). The user information and extracted characteristic data are then stored in a database.

[0158] Matching process

[0159] server:

[0160] Periodically, a batch job is run to retrieve all user information in the database, and then an algorithm is run to compare each user's ideal partner characteristics with the real data of all other users (e.g., personality, hobbies, values).

[0161] server:

[0162] The commonalities between each user pair are calculated as a score (e.g., if the commonalities "kindness" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on these scores, a list of the most compatible matching candidates is created for each user.

[0163] Notification of matching results

[0164] server:

[0165] Build a list of the most compatible candidates (e.g., top 5 candidates) and store it in a database. Generate matching results for each user and prepare to notify them sequentially.

[0166] Device:

[0167] Registered users are asked to log in and the matching results page is displayed. A list of matching candidates is notified to the user, and basic information (name, age, hobbies, etc.) and photos of each candidate are displayed.

[0168] Messaging Features

[0169] User:

[0170] Click the "Send a message" button for the candidate you like from the list of matching candidates, enter your message in the message input form, and click the "Send" button.

[0171] Device:

[0172] Forwards the sent message to the server.

[0173] server:

[0174] Save the message to a database and notify the receiving user that a new message has arrived (via email or in-app notification).

[0175] Device:

[0176] When the receiving user logs in, it displays new messages. It provides a chat interface for both parties to send and receive messages, and retrieves and displays the message history from the server.

[0177] Specific examples

[0178] Example of user registration

[0179] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[0180] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[0181] Specific example of matching process

[0182] The server executes a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities). A score is calculated based on the commonalities, and the candidate with the highest score is selected.

[0183] Specific examples of notifications

[0184] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[0185] Messaging Examples

[0186] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[0187] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[0188] The device displays the message to Hanako and provides a reply function.

[0189] Example prompts to input to the generative AI model

[0190] "Please describe your ideal partner:"

[0191] "Please extract common items from user data."

[0192] "View the matching results."

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

[0194] User Registration

[0195] Step 1:

[0196] User visits the sign-up form

[0197] Terminal: A user accesses the service's homepage and clicks the "New Registration" button displayed on the homepage. The input is the user's action (click). The output is the user registration form.

[0198] Step 2:

[0199] Enter and submit user information

[0200] User: Enters name, age, gender, email address, and ideal partner profile (personality, appearance, hobbies, values, etc.) into the form and clicks the "Register" button. User information and ideal partner profile are provided as input, and this data is passed to the terminal. As output, this information is sent to the server in JSON format.

[0201] Step 3:

[0202] The server receives and analyzes the data

[0203] Server: Temporarily stores the received user information and uses a natural language processing engine to extract characteristic keywords from the "ideal partner image" and convert them into numerical data. Specific operations include inputting the received user data (e.g., "kind, likes movies") and outputting characteristic data (e.g., "kind" = 0.9, "likes movies" = 0.8).

[0204] Step 4:

[0205] The server stores user information in a database

[0206] Server: Stores user information along with analyzed feature data in a database. User information and feature data are input, and are stored in a database as output.

[0207] Matching process

[0208] Step 1:

[0209] Running a batch job

[0210] Server: Periodically executes a batch job to retrieve all user information in the database. The input is a trigger for the batch job to be executed periodically, and the output is all user data.

[0211] Step 2:

[0212] Retrieving User Data

[0213] Server: Acquires user data to compare the characteristics of each user's ideal partner with the actual data of all other users. The input contains all user data, and the output extracts data for each user.

[0214] Step 3:

[0215] Comparison with the ideal partner

[0216] Server: Runs an algorithm that compares each user's ideal partner image with other users' data and extracts commonalities. The input is the ideal partner image and other users' data, and the output is the extracted commonalities.

[0217] Step 4:

[0218] Compatibility Score Calculation

[0219] Server: Calculates the commonalities of each user pair as a score and calculates the compatibility score. The input is the extracted commonalities data, and the output is the compatibility score (e.g., if the commonalities are "kind" = 0.9 and "likes movies" = 0.8, the total score is 1.7).

[0220] Step 5:

[0221] Generate a list of match candidates

[0222] Server: Creates a list of best-matching candidates for each user based on their compatibility score. The input is the compatibility score and all user data, and the output is a list of best-matching candidates.

[0223] Notification of matching results

[0224] Step 1:

[0225] Save the best candidates list

[0226] Server: Builds a list of best-match candidates and stores it in a database. The input is the generated list of matching candidates, and the output is stored in a database.

[0227] Step 2:

[0228] Preparing to notify users

[0229] Server: Generates matching results for each user and prepares notifications. The input is the stored list of match candidates, and the output is the prepared notifications.

[0230] Step 3:

[0231] Displaying matching results

[0232] Terminal: When a registered user logs in, the matching results page is displayed and the candidate list is notified to the user. The input is each user's login information, and the output is the matching candidate list and related candidate information.

[0233] Messaging Features

[0234] Step 1:

[0235] User sends a message

[0236] User: Clicks the "Send Message" button of the candidate he likes from the list of match candidates, enters a message and sends it. The input contains the user's message, and the output is the message sent.

[0237] Step 2:

[0238] The server receives and stores the message

[0239] Terminal: Forwards the sent message to the server.

[0240] Server: Stores messages in a database and notifies the receiving user that a new message has arrived. Input is the user's message, output is the message stored and notification sent.

[0241] Step 3:

[0242] Notifying the receiving user

[0243] Terminal: Displays new messages when the receiving user logs in. Inputs are login information and saved messages, and output is the new message.

[0244] Step 4:

[0245] Providing a chat interface and displaying message history

[0246] Terminal: Provides a chat interface for both parties to send messages to each other, and retrieves and displays past message history from the server. The input includes the message history of both parties, and the output displays the messages on the chat screen.

[0247] (Application example 1)

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

[0249] Today's consumers have diverse food preferences and lifestyles, making it difficult to efficiently find restaurants and cuisines that suit them. Finding a suitable restaurant often requires a lot of time and effort, resulting in an unsatisfactory selection. Furthermore, there is a lack of systems that allow users with similar food preferences to exchange reviews and opinions with each other. The purpose of this invention is to solve the above problems and provide an AI matching system that allows users to efficiently find their ideal cuisine and restaurant.

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

[0251] In this invention, the server includes means for registering user profile data, means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data, means for calculating compatibility scores using the user data and feature data saved in the database and generating a list of multiple candidates, means for notifying the user of the candidate list, means for providing communication means for sending and receiving messages between the user and candidates selected from the candidate list, means for inputting the user's favorite dishes and characteristics of dishes they want to eat and suggesting optimal restaurants and dishes based on the input, means for saving the characteristic information of the restaurants and dishes in the database and running a matching algorithm together with user information, and means for notifying the user of the list of restaurant and dish suggestions created by the matching algorithm. This allows users to easily find restaurants and dishes that suit their preferences and to have a richer dining experience by exchanging reviews and impressions with other users who share the same preferences.

[0252] "Profile data" refers to data that includes a user's personal information, preferences, attributes, etc.

[0253] "Ideal partner image" refers to data that expresses the characteristics and conditions of the partner that the user desires.

[0254] "Natural language processing" is a technology that uses computers to analyze and understand the natural language used by humans.

[0255] "Feature data" refers to quantified information about a user's wishes and preferences extracted through natural language processing.

[0256] The "compatibility score" is a numerical representation of the commonalities and degree of similarity between the user's wishes and preferences and the characteristics of the candidate.

[0257] A "candidate list" is a list of multiple candidates that match a user, selected based on their compatibility scores.

[0258] "Communication means" refers to the technology and infrastructure used to send and receive messages and data between users.

[0259] "Favorite dishes" refers to the food or dishes that the user particularly likes.

[0260] A "restaurant" is a business that serves food and drinks to customers.

[0261] "Characteristic information" refers to information about restaurants and their cuisine, including their characteristics, reputation, and menu composition.

[0262] A "matching algorithm" is a calculation method or process for selecting the most suitable candidate based on the user's wishes and preferences.

[0263] The following system configuration is used to implement this invention. The main components include registering user profiles, analyzing food and restaurant feature data, calculating compatibility scores, notifying matching results, and sending and receiving messages. This system also uses a natural language processing engine to analyze user input and generate quantified feature data.

[0264] System Configuration

[0265] Hardware: Servers (e.g., AWS (registered trademark) EC2), end-user smartphones

[0266] Software: Natural language processing (e.g., TENSORFLOW(R), spaCy), database (e.g., MySQL(R)), backend (e.g., Python, Django), frontend (e.g., React Native)

[0267] Registering a user profile

[0268] The server receives the data entered by the user in the new registration form and stores it in a database. The user enters their name, age, gender, email address, and ideal cuisine and restaurant characteristics (e.g., likes spicy food, likes Japanese food).

[0269] Analysis of food and restaurant feature data

[0270] The server analyzes the registered profile data using a natural language processing engine (such as TensorFlow or spaCy) to extract characteristic keywords, and stores the analysis results in a database as numerical data.

[0271] Compatibility Score Calculation

[0272] The server periodically uses the user data and feature data stored in the database to run a matching algorithm, comparing each user's features with the restaurant's characteristics, scoring commonalities and generating a list of optimal restaurants.

[0273] Notification of matching results

[0274] The server stores the generated restaurant list (top 5 restaurants) in a database and prepares to notify the user. When a registered user logs in to the app, the device displays the matching results page and provides basic information about the suggested restaurants (restaurant name, address, and cuisine characteristics).

[0275] Message sending and receiving function

[0276] The device allows users to read reviews of restaurants they like from the generated list and send and receive messages with other users. The server stores these messages in a database and notifies other users when a new message arrives.

[0277] Specific examples

[0278] Example of user profile registration

[0279] When a user registers for the app, they enter their name: Taro, age: 30, gender: male, email address: taro@example.com, ideal food and restaurant characteristics: I like spicy food, I like Japanese food.

[0280] Specific examples of feature data analysis

[0281] The server analyzes the input features "I like spicy food" and "I like Japanese food" using a natural language processing engine and stores each as numerical data in a database (e.g., "I like spicy food" = 0.9, "I like Japanese food" = 0.8).

[0282] Prompt Sentence Examples

[0283] "Kind, loves movies, loves Japanese food"

[0284] Using this prompt, the user's preferences can be quantified and the most suitable restaurant can be suggested.

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

[0286] Step 1: User Registration

[0287] The server receives the data entered by the user into the new registration form. Specifically, the server receives the user's name, age, gender, email address, ideal cuisine, and restaurant characteristics in JSON format and stores them in a database. At that time, a natural language processing engine (e.g., TensorFlow, spaCy) is used to extract characteristic keywords and convert them into numerical data (e.g., "spicy" = 0.9, "Japanese food" = 0.8). This converted data is also stored in the database.

[0288] Input: User profile data (name, age, gender, email address, ideal cuisine and restaurant characteristics)

[0289] Output: User information and feature data stored in a database

[0290] Step 2: Analyze feature data

[0291] The server uses a natural language processing engine to analyze the characteristics of the registered profile data. The analyzed characteristics are stored in a database as numerical data. This provides common characteristic information required for calculations.

[0292] Input: User profile data

[0293] Output: quantified feature data

[0294] Step 3: Calculate your compatibility score

[0295] The server periodically executes a batch job to retrieve user data and feature data stored in the database. The feature data of each user is compared with the characteristic information of all restaurants to calculate a compatibility score. Based on the score calculation algorithm, the commonalities are quantified and a list of the most suitable restaurants is generated.

[0296] Input: Customer data and restaurant characteristics information

[0297] Output: A list of the best restaurants for each user

[0298] Step 4: Notification of match results

[0299] The server stores the generated restaurant list (e.g., the top five restaurants) in a database. When the user logs in to the app, the device displays a matching results page, which shows basic information about the suggested restaurants (such as restaurant name, address, and cuisine characteristics).

[0300] Input: A list of restaurants that are best suited for each user

[0301] Output: Matching results notified to the user

[0302] Step 5: Sending and receiving messages

[0303] The terminal provides a function to read reviews of restaurants that the user likes from the restaurant list that the user created. The user can send and receive messages with other users. The server stores the sent messages in a database and notifies other users when a new message arrives.

[0304] Input: Message from user

[0305] Output: Messages sent and received, messages stored in the database

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

[0307] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. This system registers the user's profile data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a means of communication for sending and receiving messages between the candidates, and by combining it with an emotion engine, it can recognize the user's emotions and optimize the matching process.

[0308] User Registration

[0309] Device:

[0310] When a user accesses the service and opens the homepage, a login button and a new registration button are displayed. When the user clicks the "New Registration" button, a user registration form is displayed.

[0311] User:

[0312] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values, etc.) in the form and click the "Register" button.

[0313] Device:

[0314] The entered user information is converted to JSON format and sent to the server.

[0315] server:

[0316] The received data is temporarily stored. The "ideal partner image" is analyzed using a natural language processing engine to extract characteristic keywords. The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8). The user information and characteristic data are then stored in a database.

[0317] Matching process and emotion engine usage

[0318] server:

[0319] Periodically, a batch job is run to retrieve all user information in the database, and then an algorithm is run to compare each user's ideal partner characteristics with the actual data of all other users.

[0320] The commonalities between each user pair are calculated as a score (e.g., if the commonalities are "kind" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on the calculated scores, a list of compatible candidates is generated for each user.

[0321] Furthermore, an emotion engine is used to recognize emotions from the content of users' messages. The recognized emotion data is then taken into consideration during matching to select more suitable candidates.

[0322] Notification of matching results

[0323] server:

[0324] Build a list of the most compatible candidates (e.g., top 5). Prepare and save the matching result data for each user.

[0325] Device:

[0326] When a user logs in, a matching results page will be displayed. A list of matching candidates will be notified to the user, and basic information (name, age, hobbies, etc.) and photos of each candidate will be displayed.

[0327] Use of messaging features and emotion engines

[0328] User:

[0329] Click the "Send Message" button for the candidate you like from the list of matching candidates. Enter your message in the message input form and click the "Send" button.

[0330] Device:

[0331] Forwards the sent message to the server.

[0332] server:

[0333] Save the message to a database and notify the receiving user (via email or in-app notification) that a new message has arrived.

[0334] It also uses an emotion engine to analyze the emotions in sent messages and provides suggestions to optimize the next communication based on the recognized emotion data.

[0335] Device:

[0336] It displays new messages when the receiving user logs in. It provides a chat interface for both parties to send messages to each other, and retrieves and displays message history from the server.

[0337] Specific examples

[0338] Example of user registration

[0339] When the device is accessed for the first time, it displays a user registration form, and the user enters "Name: Taro, Age: 30, Gender: Male, Email address: taro@example.com, Ideal partner: A kind woman who likes movies." The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[0340] Specific example of matching process

[0341] The server runs a batch job, retrieves all user data, and calculates the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities). A score is calculated based on the commonalities, and an emotion engine is used to consider emotional data to select the candidate with the highest score.

[0342] Specific examples of notifications

[0343] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[0344] Messaging Examples

[0345] The user selects Hanako from the list of candidates and enters the message "Hello, this is Taro. I heard you like movies, so I'm messaging you!" The device forwards the message to the server, which notifies Hanako of the new message. The emotion engine recognizes the emotion of the message and stores that data. From the next time onwards, suggestions are provided that take the emotion data into account. The device displays the message to Hanako and provides a reply function.

[0346] The processing flow will be explained below.

[0347] Program processing steps

[0348] Step 1: User Registration

[0349] 1. Device:

[0350] Displays the homepage and provides login and registration buttons.

[0351] When the user clicks the "New Registration" button, a user registration form is displayed.

[0352] 2. User:

[0353] Enter your name, age, gender, email address, and ideal partner (personality, hobbies, values, etc.) in the form.

[0354] Click the "Register" button.

[0355] 3. Terminal:

[0356] The entered user information is converted to JSON format and sent to the server.

[0357] 4. Server:

[0358] Temporarily saves received data.

[0359] The natural language processing engine analyzes the "ideal partner image" and extracts characteristic keywords.

[0360] The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8).

[0361] Store user information and feature data in a database.

[0362] Step 2: Matching process and using the emotion engine

[0363] 1. Server:

[0364] Periodically run a batch job to retrieve all user information in the database.

[0365] It runs an algorithm that compares the characteristics of each user's ideal partner with the real data of all other users.

[0366] 2. Server:

[0367] The commonality between each user pair is calculated as a score (e.g., if the commonality "kindness" = 0.9 and the commonality "likes movies" = 0.8, the total score = 1.7).

[0368] Based on the calculated score, a list of compatible candidates is generated for each user.

[0369] Furthermore, an emotion engine is used to recognize emotions from the content of the user's message.

[0370] The recognized emotion data is used to take into consideration during matching to select more suitable candidates.

[0371] Step 3: Notification of match results

[0372] 1. Server:

[0373] Build a list of the most compatible candidates (e.g., top 5).

[0374] Prepare and store matching result data for each user.

[0375] 2. Terminal:

[0376] When a user logs in, a matching results page will be displayed.

[0377] The user is notified of a list of matching candidates, and basic information (name, age, hobbies, etc.) and a photo of each candidate are displayed.

[0378] Step 4: Use messaging and emotion engines

[0379] 1. User:

[0380] Click the "Send Message" button for the candidate you like from the list of matching candidates.

[0381] Enter your message in the message input form and click the "Send" button.

[0382] 2. Terminal:

[0383] Forwards the sent message to the server.

[0384] 3. Server:

[0385] Save the message in the database.

[0386] Notify the receiving user that a new message has arrived (via email or in-app notification).

[0387] It also uses an emotion engine to analyze the emotions in sent messages and provides suggestions to optimize the next communication based on the recognized emotion data.

[0388] 4. Terminal:

[0389] Displays new messages when the receiving user logs in.

[0390] It provides a chat interface for both parties to send messages to each other.

[0391] Retrieve and display message history from the server.

[0392] Specific examples

[0393] Step 1 example

[0394] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[0395] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[0396] Step 2: Example

[0397] The server runs a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities).

[0398] A score is calculated based on commonalities, and then an emotion engine is used to take emotional data into account to select the candidate with the highest score.

[0399] Step 3 example

[0400] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[0401] Step 4: Example

[0402] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[0403] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[0404] It uses an emotion engine to recognize the emotion of the message and stores that data as well.

[0405] The system will provide suggestions that take emotional data into account in future messaging.

[0406] The device displays the message to Hanako and provides a reply function.

[0407] Example 2

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

[0409] Conventional matching systems have the problem of being unable to accurately analyze a user's ideal partner and present appropriate candidates. Furthermore, they lack the means to support communication between candidates and promote smooth relationship building, in addition to generating and notifying candidate lists. Furthermore, because they are unable to match users based on their emotions, potential compatibility may not be fully realized.

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

[0411] In this invention, the server includes means for registering user attribute data, means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data, means for calculating compatibility scores and generating a list of multiple candidates using the user data and feature data saved in the database, means for notifying the user of the candidate list, means for providing communication means for sending and receiving information to and from candidates selected from the candidate list, and means for analyzing emotional data in the sent and received information using an emotion analysis engine and optimizing the matching process. This makes it possible to accurately analyze the user's ideal partner image, present the most suitable candidates, and optimize communication taking the emotional data into consideration.

[0412] "User" refers to an individual who uses this system, registers profile data, and receives matching services.

[0413] "Attribute data" refers to information about users provided by users, such as their name, age, gender, email address, and ideal partner image.

[0414] "Natural language processing" refers to the technology of analyzing text data provided by users and extracting meaning and characteristics from it.

[0415] "Feature data" refers to data that quantifies information about an ideal partner extracted through natural language processing.

[0416] "Database" refers to a system for storing user data and characteristic data and for searching and updating them as needed.

[0417] "Compatibility score" refers to the score calculated by comparing a user's ideal partner with the data of other users.

[0418] "Candidate List" refers to a list of potential partners who are compatible with the user, generated based on the compatibility score.

[0419] "Communication means" refers to means for sending and receiving information such as messages between users.

[0420] "Sentiment analysis engine" refers to an analytical device or software that analyzes the content of a message and recognizes the emotions contained therein.

[0421] "Optimization" refers to a method or process for maximizing the efficiency and effectiveness of the matching process and communication, taking into account emotional data, etc.

[0422] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. This system registers the user's attribute data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a means of communication for sending and receiving information between the users and the candidates. By combining this with an emotion analysis engine, the system can recognize the user's emotions and optimize the matching process.

[0423] User Registration

[0424] Device:

[0425] When a user accesses the service and opens the homepage, a login button and a new registration button are displayed. When the user clicks the "New Registration" button, a user registration form is displayed.

[0426] User:

[0427] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values) in the form and click the "Register" button. As a concrete example, a user enters "Name: Taro, Age: 30, Gender: Male, Email address: taro@example.com, Ideal partner: Kind woman who likes movies."

[0428] Device:

[0429] The entered user information is converted to JSON format and sent to the server.

[0430] server:

[0431] The received data is temporarily stored. The "ideal partner" is analyzed using a natural language processing engine (e.g., SpaCy or BERT) to extract characteristic keywords. The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8). The user information and characteristic data are then stored in a database.

[0432] Matching process and emotion engine usage

[0433] server:

[0434] Periodically, a batch job is run to retrieve all user information in the database. An algorithm is run to compare the characteristics of each user's ideal partner with the actual data of all other users. The commonalities between each user pair are calculated as a score (e.g., if the commonalities are "kind" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on the calculated scores, a list of compatible candidates is generated for each user.

[0435] Furthermore, a sentiment analysis engine (e.g., Microsoft® Azure® Text Analytics API) is used to recognize emotions from the content of users' messages. The recognized emotional data is then taken into consideration during matching to select more suitable candidates.

[0436] Notification of matching results

[0437] server:

[0438] Build a list of the most compatible candidates (e.g., top 5). Prepare and save the matching result data for each user.

[0439] Device:

[0440] When a user logs in, a matching results page is displayed. The user is notified of a list of matching candidates, and basic information (name, age, hobbies, etc.) and photos of each candidate are displayed. As a specific example, the server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobbies: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[0441] Use of messaging features and emotion engines

[0442] User:

[0443] Click the "Send Message" button for the candidate you like from the list of matching candidates. Enter a message in the message input form and click the "Send" button. For example, a user might enter "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[0444] Device:

[0445] Forwards the sent message to the server.

[0446] server:

[0447] It stores messages in a database, notifies the receiving user of new messages (via email or in-app notification), and uses a sentiment analysis engine to analyze the sentiment of the message and provide suggestions to optimize the next communication based on the recognized sentiment data.

[0448] Device:

[0449] It displays new messages when the receiving user logs in. It provides a chat interface for both parties to send messages to each other, and retrieves and displays message history from the server.

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

[0451] Step 1:

[0452] The user fills out the registration form

[0453] explanation:

[0454] A user accesses the system's homepage and clicks the "New Registration" button. A registration form is then displayed. The user enters their name, age, gender, email address, and ideal partner profile (personality, appearance, hobbies, and values).

[0455] input:

[0456] User inputs name, age, gender, email address, and ideal partner image

[0457] output:

[0458] User-entered data

[0459] Specific behavior:

[0460] A user enters "Name: Taro, Age: 30, Gender: Male, Email address: taro@example.com, Ideal partner: Kind woman who likes movies."

[0461] Step 2:

[0462] The device sends user input to the server

[0463] explanation:

[0464] The device converts the data entered in the registration form into JSON format and sends the converted data to the server using an HTTP POST request.

[0465] input:

[0466] User-entered data

[0467] output:

[0468] JSON format data

[0469] Specific behavior:

[0470] The device will generate JSON data like this:

[0471] json

[0472] {

[0473] "Name": "Taro",

[0474] "Age": 30,

[0475] "Gender": "Male",

[0476] "Email address": "taro@example.com",

[0477] "Ideal partner": "A kind woman who loves movies"

[0478] }

[0479] POST the converted data to https: / / example.com / api / register.

[0480] Step 3:

[0481] The server processes the received data and stores it in a database

[0482] explanation:

[0483] The server parses the received JSON data. It uses a natural language processing engine (e.g., SpaCy or BERT) to analyze the "ideal partner" field and extracts characteristic keywords. It converts these characteristics into numerical values, e.g., "kind" = 0.9, "likes movies" = 0.8. It then stores these values ​​in a database along with the overall user data.

[0484] input:

[0485] User data in JSON format

[0486] output:

[0487] User information and feature data stored in a database

[0488] Specific behavior:

[0489] The server does the following:

[0490] 1. Parse the JSON data.

[0491] 2. Use a natural language processing engine to extract characteristic keywords such as "kind" and "likes movies."

[0492] 3. Quantify the characteristic keywords.

[0493] 4. Store user information and feature data in a database.

[0494] Step 4:

[0495] The server runs a batch job to retrieve the user data

[0496] explanation:

[0497] A scheduled batch job runs at regular intervals to retrieve all user data from the database.

[0498] input:

[0499] All user data stored in the database

[0500] output:

[0501] All user data obtained

[0502] Specific behavior:

[0503] The server periodically runs a batch job to retrieve all user information from the database.

[0504] Step 5:

[0505] The server calculates compatibility scores and generates a candidate list.

[0506] explanation:

[0507] Based on the acquired user data, an algorithm is run to compare each user's ideal partner image with the data of all other users. The more commonalities there are, the higher the compatibility score is calculated, and a list of compatible candidates is generated for each user.

[0508] input:

[0509] All user data

[0510] output:

[0511] Candidate list for each user

[0512] Specific behavior:

[0513] The server does the following:

[0514] 1. Compare each user's ideal partner profile with all other user data.

[0515] 2. The score is calculated so that the more commonalities there are, the higher the score.

[0516] 3. Generate a list of compatible candidates for each user.

[0517] Step 6:

[0518] The server uses a sentiment analysis engine to optimize matching.

[0519] explanation:

[0520] The content of the messages is analyzed to extract the emotional data contained within them. A sentiment analysis engine is used to recognize the sentiment of the messages, and this data is fed back into the matching process to select more suitable candidates.

[0521] input:

[0522] Message content

[0523] output:

[0524] Emotional Data

[0525] Specific behavior:

[0526] The server does the following:

[0527] 1. Input the message into the sentiment analysis engine.

[0528] 2. Obtain emotional data using a sentiment analysis engine.

[0529] 3. Use sentiment data to optimize the matching process.

[0530] Step 7:

[0531] The server builds a list of candidates and stores it in a database

[0532] explanation:

[0533] A list of the most compatible candidates is constructed and the matching result data for each user is stored in a database.

[0534] input:

[0535] List of candidates with high compatibility scores

[0536] output:

[0537] Matching result data stored in the database

[0538] Specific behavior:

[0539] The server does the following:

[0540] 1. Build a shortlist based on compatibility scores.

[0541] 2. Save the matching result data in the database.

[0542] Step 8:

[0543] The device notifies the user of the matching results

[0544] explanation:

[0545] When a user logs in, the matching results are retrieved from the server and displayed on the homepage. A list of candidates is displayed, along with basic information and photos of each candidate.

[0546] input:

[0547] Matching result data stored in the database

[0548] output:

[0549] A list of matching candidates displayed on the screen

[0550] Specific behavior:

[0551] The device will:

[0552] 1. The user logs in.

[0553] 2. Get the matching results from the server.

[0554] 3. Display a list of matching candidates, along with basic information and photos of each candidate.

[0555] Step 9:

[0556] The user types and sends a message

[0557] explanation:

[0558] Select a specific candidate from the list of matching candidates, enter a message, and click the "Send" button.

[0559] input:

[0560] A message entered by the user

[0561] output:

[0562] Message data to be sent

[0563] Specific behavior:

[0564] The user types, "Hi, I'm Taro. I heard you like movies, so I'm messaging you!"

[0565] Step 10:

[0566] The device forwards the message to the server

[0567] explanation:

[0568] The input message is converted back to JSON format for transmission to the server and sent using an HTTP request.

[0569] input:

[0570] A message entered by the user

[0571] output:

[0572] Message data in JSON format

[0573] Specific behavior:

[0574] The device generates the following JSON data and sends it to the server:

[0575] json

[0576] {

[0577] "Sender": "Taro",

[0578] "Recipient": "Hanako",

[0579] "Message": "Hello, I'm Taro. I heard you like movies, so I messaged you!"

[0580] }

[0581] Step 11:

[0582] The server notifies the receiving user and parses the message.

[0583] explanation:

[0584] The message is saved in a database, the receiving user is notified that a new message has arrived, and the message content is analyzed using an emotion analysis engine, and the emotional data is saved for use in the next communication.

[0585] input:

[0586] Message data sent

[0587] output:

[0588] Notifications sent to the receiving user and stored emotion data

[0589] Specific behavior:

[0590] The server does the following:

[0591] 1. Save the message in the database.

[0592] 2. Send a notification to the recipient user.

[0593] 3. The sentiment analysis engine analyzes the sentiment of the message and stores the data.

[0594] Step 12:

[0595] The device displays the new message to the receiving user.

[0596] explanation:

[0597] When the receiving user logs in, it displays new messages and provides reply functionality.

[0598] input:

[0599] New messages notified

[0600] output:

[0601] New on-screen messaging and reply features

[0602] Specific behavior:

[0603] The device will:

[0604] 1. The receiving user logs in.

[0605] 2. View new messages.

[0606] 3. Provide a reply function.

[0607] (Application example 2)

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

[0609] Conventional matching systems sometimes had difficulty proposing suitable candidates and products based on users' preferences and tendencies. Additionally, they lacked a mechanism to understand the emotions expressed in messages sent by users through the system and provide optimal support accordingly, which resulted in a lack of improvement in the user experience.

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

[0611] In this invention, the server includes means for registering user identification information, means for analyzing the ideal target image provided by the user using natural language processing and saving it as feature data, means for calculating an evaluation score using the user data and feature data saved in the database and generating multiple recommendation lists, means for notifying the user of the recommendation lists, means for providing a communication means for sending and receiving messages to targets selected from the recommendation lists, and means for analyzing the emotions in the messages and providing optimal support, thereby making it possible to suggest suitable candidates and products to the user and provide optimal support according to their emotions.

[0612] "User" refers to an individual who uses the system to register profile data and receive matching and product recommendations.

[0613] "Identification information" is data used to identify an individual user, and often includes basic information such as name and email address.

[0614] "Natural language processing" is a set of techniques that allow computers to understand human language, and involves analyzing text data and extracting features.

[0615] "Feature data" is data that quantifies or categorizes the user's ideal target image, and is used as a basis for matching and recommendations.

[0616] The "evaluation score" is a numerical representation of the compatibility between the user's characteristic data and the target data, and is used to generate a recommendation list.

[0617] A "recommended list" is a list of candidates or products provided to a user, selected based on compatibility and preferences.

[0618] "Notification" is a means of notifying users of the contents of a recommendation list or the arrival of a message.

[0619] "Communication means" refers to the technical means for sending and receiving messages between users, and is realized via the Internet or applications.

[0620] "Sentiment analysis" is a technology that uses natural language processing to analyze the emotions in messages sent by users and extract emotional data.

[0621] "Support" refers to the act of providing appropriate advice and support regarding users' messages and actions based on data obtained through sentiment analysis.

[0622] This invention is based on an AI-based system that provides optimal support to users by registering user identification information, generating feature data using natural language processing, calculating evaluation scores, generating and notifying recommendation lists, and analyzing message sentiment.

[0623] Specifically, this system includes a server, a terminal, and a means of communication between users. The main processing steps and the hardware and software used are shown below.

[0624] First, the server has the function of receiving and registering identification information from users. This identification information includes basic data such as name and email address. When a user registers, the data entered through the terminal is sent to the server and saved in JSON format.

[0625] The server then analyzes the ideal target image entered by the user using a natural language processing (NLP) engine. This analysis uses open-source NLP tools such as "NLTK" and "SpaCy." The analyzed data is quantified as feature data and stored in a database.

[0626] The server periodically runs a batch job to retrieve all user data and feature data stored in the database. Based on each user's feature data, it uses scikit-learn's TfidfVectorizer and cosine_similarity to calculate an evaluation score. This generates and stores multiple recommendation lists.

[0627] When a user logs in to their device, the server notifies them of the generated recommendation list, which includes the best candidates based on the user's preferences and rating scores. The notification is made on a web page or mobile application, and the contents of the recommendation list are displayed.

[0628] Furthermore, it provides a real-time communication means for sending and receiving messages between users. Sent messages are transferred to the server and stored in a database. At the same time, the message content is analyzed using an emotion analysis engine (e.g., TextBlob), and the identified emotion data is stored.

[0629] As a specific example, if a user inputs "a woman who loves movies" as their ideal partner, the system will quantify the characteristic "movies" and display a list of recommended partners with similar characteristics. Furthermore, if a user sends a message saying, "Tell me more about this product," the system will use a sentiment analysis engine to distinguish whether the message is positive or negative, and provide the most appropriate support accordingly. For example, a positive message will display a "detailed product description," while a negative message will display "problem-solving guidance."

[0630] Example prompt sentence:

[0631] "Show us how to recommend products based on user preferences."

[0632] "Please explain how to analyze the sentiment of a user's message to provide optimal support."

[0633] As described above, this system provides optimal recommendations and support that take into account the user's preferences and emotions, thereby improving the user experience.

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

[0635] Step 1:

[0636] The user accesses the registration page using a device and enters identification information (name, email address, etc.) and their ideal partner (personality, hobbies, etc.). The entered information is sent to the server in JSON format.

[0637] Input: User's identity and ideal image

[0638] Data processing: Converts text data entered by the user into JSON format

[0639] Output: Data sent to the server in JSON format

[0640] Step 2:

[0641] The server parses the received JSON data and extracts the user's identity and ideal target. The ideal target is analyzed using a natural language processing (NLP) engine (e.g., NLTK, SpaCy) and quantified as feature data. This feature data and identity are then stored in a database.

[0642] Input: JSON formatted identity and ideal target image

[0643] Data processing: Text analysis and quantification using an NLP engine

[0644] Output: Feature data and identification information stored in a database

[0645] Step 3:

[0646] The server periodically runs a batch job to retrieve all user data and feature data from the database. Using the retrieved data, it calculates a rating score for each user along with the data of other users and products. This rating score is calculated using TfidfVectorizer and cosine_similarity (scikit-learn).

[0647] Input: All user data and feature data in the database

[0648] Data processing: Vectorization by TfidfVectorizer and scoring by cosine_similarity

[0649] Output: Rating score for each user

[0650] Step 4:

[0651] The server generates multiple recommendation lists for each user based on the evaluation scores, sorting the candidates in descending order of evaluation score, and stores the lists in a database.

[0652] Input: Rating score

[0653] Data processing: Generate a list based on the evaluation scores

[0654] Output: Recommendation list

[0655] Step 5:

[0656] When a user logs in to their device, the server sends the recommended list to the user's device. Information on the recommended candidates is displayed, and the user can select the candidates and products they want.

[0657] Input: Recommendation List

[0658] Data processing: Get and notify the recommendation list

[0659] Output: Recommendation list displayed on the user's device

[0660] Step 6:

[0661] The user selects a candidate from the recommended list and sends a message. The device forwards the message to the server, which stores it in a database. The server also uses a sentiment analysis engine (TextBlob) to identify the sentiment of the message and optimizes the next communication based on the results.

[0662] Input: The message the user sends

[0663] Data processing: Extracting emotional data using a sentiment analysis engine

[0664] Output: Sentiment analysis results and saved messages

[0665] Step 7:

[0666] The server considers the emotional data of the message and provides optimal support, for example, providing detailed explanations for positive messages and problem-solving guidance for negative messages, thereby improving user satisfaction.

[0667] Input: Sentiment analysis results

[0668] Data processing: Selection of support content

[0669] Output: Optimal support message for the user

[0670] The above are the specific processing steps of the system that realizes the application example.

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

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

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

[0674] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

[0685] In the smart glasses 214, 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.

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

[0687] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. This system registers the user's profile data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a communication means for sending and receiving messages between candidates. The specific operation of this system is described below.

[0688] User Registration

[0689] Device:

[0690] When a user accesses the service and opens the homepage, a login button and a new registration button are displayed. When the user clicks the "New Registration" button, a user registration form is displayed.

[0691] User:

[0692] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values, etc.) in the form and click the "Register" button.

[0693] Device:

[0694] The entered user information is sent to the server in JSON format.

[0695] server:

[0696] The received data is temporarily stored, and characteristic keywords are extracted from the "ideal partner image" using a natural language processing engine and converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8, etc.). The user information and extracted characteristic data are then stored in a database.

[0697] Matching process

[0698] server:

[0699] Periodically, a batch job is run to retrieve all user information in the database, and then an algorithm is run to compare each user's ideal partner characteristics with the real data of all other users (e.g., personality, hobbies, values).

[0700] server:

[0701] The commonalities between each user pair are calculated as a score (e.g., if the commonalities "kindness" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on these scores, a list of the most compatible matching candidates is created for each user.

[0702] Notification of matching results

[0703] server:

[0704] Build a list of the most compatible candidates (e.g., top 5 candidates) and store it in a database. Generate matching results for each user and prepare to notify them sequentially.

[0705] Device:

[0706] Registered users are asked to log in and the matching results page is displayed. A list of matching candidates is notified to the user, and basic information (name, age, hobbies, etc.) and photos of each candidate are displayed.

[0707] Messaging Features

[0708] User:

[0709] Click the "Send a message" button for the candidate you like from the list of matching candidates, enter your message in the message input form, and click the "Send" button.

[0710] Device:

[0711] Forwards the sent message to the server.

[0712] server:

[0713] Save the message to a database and notify the receiving user that a new message has arrived (via email or in-app notification).

[0714] Device:

[0715] When the receiving user logs in, it displays new messages. It provides a chat interface for both parties to send and receive messages, and retrieves and displays the message history from the server.

[0716] (Example)

[0717] Example of user registration

[0718] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[0719] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[0720] Specific example of matching process

[0721] The server executes a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities). A score is calculated based on the commonalities, and the candidate with the highest score is selected.

[0722] Specific examples of notifications

[0723] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[0724] Messaging Examples

[0725] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[0726] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[0727] The device displays the message to Hanako and provides a reply function.

[0728] The processing flow will be explained below.

[0729] Program processing steps

[0730] Step 1: User Registration

[0731] 1. Device:

[0732] Display the homepage and display the login and new registration buttons.

[0733] When the user clicks the "New Registration" button, a user registration form is displayed.

[0734] 2. User:

[0735] Enter your name, age, gender, email address, and ideal partner (personality, hobbies, values, etc.) in the user registration form.

[0736] Click the "Register" button.

[0737] 3. Terminal:

[0738] The entered user information is converted to JSON format and sent to the server.

[0739] 4. Server:

[0740] Temporarily saves received data.

[0741] The natural language processing engine analyzes the "ideal partner image" and extracts characteristic keywords.

[0742] The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8).

[0743] Store user information and feature data in a database.

[0744] Step 2: Matching

[0745] 1. Server:

[0746] Periodically run a batch job to retrieve all user information in the database.

[0747] The characteristics of each user's ideal partner are compared with the actual data of all other users.

[0748] 2. Server:

[0749] The commonality between each user pair is calculated as a score (e.g., if the commonality "kindness" = 0.9 and the commonality "likes movies" = 0.8, the total score = 1.7).

[0750] Based on the calculated score, a list of compatible candidates is generated for each user.

[0751] Step 3: Notification of match results

[0752] 1. Server:

[0753] Build a list of the most compatible candidates (e.g., top 5).

[0754] Prepare and store matching result data for each user.

[0755] 2. Terminal:

[0756] When a user logs in, a matching results page will be displayed.

[0757] The user is notified of a list of matching candidates and basic information and photos of each candidate are displayed.

[0758] Step 4: Messaging Features

[0759] 1. User:

[0760] Click the "Send Message" button for the candidate you like from the list of matching candidates.

[0761] Enter your message in the message input form and click the "Send" button.

[0762] 2. Terminal:

[0763] Forwards the sent message to the server.

[0764] 3. Server:

[0765] Save the message in the database.

[0766] Notify the receiving user that a new message has arrived (via email or in-app notification).

[0767] 4. Terminal:

[0768] Displays new messages when the receiving user logs in.

[0769] It provides a chat interface for both parties to send messages to each other.

[0770] Retrieve and display message history from the server.

[0771] Specific examples

[0772] Step 1 example

[0773] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[0774] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[0775] Step 2: Example

[0776] The server runs a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities).

[0777] A score is calculated based on commonalities, and the candidate with the highest score is selected.

[0778] Step 3 example

[0779] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[0780] Step 4: Example

[0781] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[0782] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[0783] The device displays the message to Hanako and provides a reply function.

[0784] Example 1

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

[0786] Conventional matching systems were unable to effectively analyze users' ideal partner profiles, making it difficult to accurately assess compatibility with potential partners. Furthermore, they struggled to smoothly exchange messages with potential partners, leaving a need for an improved user experience.

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

[0788] In this invention, the server includes means for registering user profile data, means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data, means for calculating compatibility scores using the user data and feature data saved in the database and generating multiple candidate lists, means for notifying the user of the candidate list, means for providing communication means for sending and receiving messages with candidates selected from the candidate list, and means for displaying the candidate list and related candidate information on a user interface, thereby enabling users to efficiently meet their ideal partner.

[0789] "User profile data" refers to data that includes personal information and attribute information provided by a user.

[0790] The "ideal partner image" is data that represents the characteristics of the user's desired partner, such as personality, appearance, hobbies, and values.

[0791] "Natural language processing" is a technology that allows computers to understand and interpret human language and extract specific information.

[0792] "Feature data" is data that quantifies the ideal partner image extracted through natural language processing.

[0793] A "database" is a system that systematically stores and manages user profile data and characteristic data.

[0794] A "compatibility score" is an evaluation index calculated based on the commonalities and similarities between the user and the candidate.

[0795] A "candidate list" is a list of multiple suitable partner candidates selected based on their compatibility scores.

[0796] "Notification" is the act of informing the user of results or information.

[0797] "Communication means" refers to the technical means by which messages are sent and received between users.

[0798] A "user interface" is a screen or operating means that allows a user to interact with a system.

[0799] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. The system registers the user's profile data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a communication means for sending and receiving messages between the users and the candidates.

[0800] User Registration

[0801] Device:

[0802] When a user accesses the service, a login button and a new registration button are displayed on the home page. When a user clicks the "New Registration" button, a user registration form is displayed.

[0803] User:

[0804] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values, etc.) in the form and click the "Register" button.

[0805] Device:

[0806] The entered user information is sent to the server in JSON format.

[0807] server:

[0808] The received data is temporarily stored, and characteristic keywords are extracted from the "ideal partner image" using a natural language processing engine and converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8, etc.). The user information and extracted characteristic data are then stored in a database.

[0809] Matching process

[0810] server:

[0811] Periodically, a batch job is run to retrieve all user information in the database, and then an algorithm is run to compare each user's ideal partner characteristics with the real data of all other users (e.g., personality, hobbies, values).

[0812] server:

[0813] The commonalities between each user pair are calculated as a score (e.g., if the commonalities "kindness" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on these scores, a list of the most compatible matching candidates is created for each user.

[0814] Notification of matching results

[0815] server:

[0816] Build a list of the most compatible candidates (e.g., top 5 candidates) and store it in a database. Generate matching results for each user and prepare to notify them sequentially.

[0817] Device:

[0818] Registered users are asked to log in and the matching results page is displayed. A list of matching candidates is notified to the user, and basic information (name, age, hobbies, etc.) and photos of each candidate are displayed.

[0819] Messaging Features

[0820] User:

[0821] Click the "Send a message" button for the candidate you like from the list of matching candidates, enter your message in the message input form, and click the "Send" button.

[0822] Device:

[0823] Forwards the sent message to the server.

[0824] server:

[0825] Save the message to a database and notify the receiving user that a new message has arrived (via email or in-app notification).

[0826] Device:

[0827] When the receiving user logs in, it displays new messages. It provides a chat interface for both parties to send and receive messages, and retrieves and displays the message history from the server.

[0828] Specific examples

[0829] Example of user registration

[0830] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[0831] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[0832] Specific example of matching process

[0833] The server executes a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities). A score is calculated based on the commonalities, and the candidate with the highest score is selected.

[0834] Specific examples of notifications

[0835] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[0836] Messaging Examples

[0837] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[0838] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[0839] The device displays the message to Hanako and provides a reply function.

[0840] Example prompts to input to the generative AI model

[0841] "Please describe your ideal partner:"

[0842] "Please extract common items from user data."

[0843] "View the matching results."

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

[0845] User Registration

[0846] Step 1:

[0847] User visits the sign-up form

[0848] Terminal: A user accesses the service's homepage and clicks the "New Registration" button displayed on the homepage. The input is the user's action (click). The output is the user registration form.

[0849] Step 2:

[0850] Enter and submit user information

[0851] User: Enters name, age, gender, email address, and ideal partner profile (personality, appearance, hobbies, values, etc.) into the form and clicks the "Register" button. User information and ideal partner profile are provided as input, and this data is passed to the terminal. As output, this information is sent to the server in JSON format.

[0852] Step 3:

[0853] The server receives and analyzes the data

[0854] Server: Temporarily stores the received user information and uses a natural language processing engine to extract characteristic keywords from the "ideal partner image" and convert them into numerical data. Specific operations include inputting the received user data (e.g., "kind, likes movies") and outputting characteristic data (e.g., "kind" = 0.9, "likes movies" = 0.8).

[0855] Step 4:

[0856] The server stores user information in a database

[0857] Server: Stores user information along with analyzed feature data in a database. User information and feature data are input, and are stored in a database as output.

[0858] Matching process

[0859] Step 1:

[0860] Running a batch job

[0861] Server: Periodically executes a batch job to retrieve all user information in the database. The input is a trigger for the batch job to be executed periodically, and the output is all user data.

[0862] Step 2:

[0863] Retrieving User Data

[0864] Server: Acquires user data to compare the characteristics of each user's ideal partner with the actual data of all other users. The input contains all user data, and the output extracts data for each user.

[0865] Step 3:

[0866] Comparison with the ideal partner

[0867] Server: Runs an algorithm that compares each user's ideal partner image with other users' data and extracts commonalities. The input is the ideal partner image and other users' data, and the output is the extracted commonalities.

[0868] Step 4:

[0869] Compatibility Score Calculation

[0870] Server: Calculates the commonalities of each user pair as a score and calculates the compatibility score. The input is the extracted commonalities data, and the output is the compatibility score (e.g., if the commonalities are "kind" = 0.9 and "likes movies" = 0.8, the total score is 1.7).

[0871] Step 5:

[0872] Generate a list of match candidates

[0873] Server: Creates a list of best-matching candidates for each user based on their compatibility score. The input is the compatibility score and all user data, and the output is a list of best-matching candidates.

[0874] Notification of matching results

[0875] Step 1:

[0876] Save the best candidates list

[0877] Server: Builds a list of best-match candidates and stores it in a database. The input is the generated list of matching candidates, and the output is stored in a database.

[0878] Step 2:

[0879] Preparing to notify users

[0880] Server: Generates matching results for each user and prepares notifications. The input is the stored list of match candidates, and the output is the prepared notifications.

[0881] Step 3:

[0882] Displaying matching results

[0883] Terminal: When a registered user logs in, the matching results page is displayed and the candidate list is notified to the user. The input is each user's login information, and the output is the matching candidate list and related candidate information.

[0884] Messaging Features

[0885] Step 1:

[0886] User sends a message

[0887] User: Clicks the "Send Message" button of the candidate he likes from the list of match candidates, enters a message and sends it. The input contains the user's message, and the output is the message sent.

[0888] Step 2:

[0889] The server receives and stores the message

[0890] Terminal: Forwards the sent message to the server.

[0891] Server: Stores messages in a database and notifies the receiving user that a new message has arrived. Input is the user's message, output is the message stored and notification sent.

[0892] Step 3:

[0893] Notifying the receiving user

[0894] Terminal: Displays new messages when the receiving user logs in. Inputs are login information and saved messages, and output is the new message.

[0895] Step 4:

[0896] Providing a chat interface and displaying message history

[0897] Terminal: Provides a chat interface for both parties to send messages to each other, and retrieves and displays past message history from the server. The input includes the message history of both parties, and the output displays the messages on the chat screen.

[0898] (Application example 1)

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

[0900] Today's consumers have diverse food preferences and lifestyles, making it difficult to efficiently find restaurants and cuisines that suit them. Finding a suitable restaurant often requires a lot of time and effort, resulting in an unsatisfactory selection. Furthermore, there is a lack of systems that allow users with similar food preferences to exchange reviews and opinions with each other. The purpose of this invention is to solve the above problems and provide an AI matching system that allows users to efficiently find their ideal cuisine and restaurant.

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

[0902] In this invention, the server includes means for registering user profile data, means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data, means for calculating compatibility scores using the user data and feature data saved in the database and generating a list of multiple candidates, means for notifying the user of the candidate list, means for providing communication means for sending and receiving messages between the user and candidates selected from the candidate list, means for inputting the user's favorite dishes and characteristics of dishes they want to eat and suggesting optimal restaurants and dishes based on the input, means for saving the characteristic information of the restaurants and dishes in the database and running a matching algorithm together with user information, and means for notifying the user of the list of restaurant and dish suggestions created by the matching algorithm. This allows users to easily find restaurants and dishes that suit their preferences and to have a richer dining experience by exchanging reviews and impressions with other users who share the same preferences.

[0903] "Profile data" refers to data that includes a user's personal information, preferences, attributes, etc.

[0904] "Ideal partner image" refers to data that expresses the characteristics and conditions of the partner that the user desires.

[0905] "Natural language processing" is a technology that uses computers to analyze and understand the natural language used by humans.

[0906] "Feature data" refers to quantified information about a user's wishes and preferences extracted through natural language processing.

[0907] The "compatibility score" is a numerical representation of the commonalities and degree of similarity between the user's wishes and preferences and the characteristics of the candidate.

[0908] A "candidate list" is a list of multiple candidates that match a user, selected based on their compatibility scores.

[0909] "Communication means" refers to the technology and infrastructure used to send and receive messages and data between users.

[0910] "Favorite dishes" refers to the food or dishes that the user particularly likes.

[0911] A "restaurant" is a business that serves food and drinks to customers.

[0912] "Characteristic information" refers to information about restaurants and their cuisine, including their characteristics, reputation, and menu composition.

[0913] A "matching algorithm" is a calculation method or process for selecting the most suitable candidate based on the user's wishes and preferences.

[0914] The following system configuration is used to implement this invention. The main components include registering user profiles, analyzing food and restaurant feature data, calculating compatibility scores, notifying matching results, and sending and receiving messages. This system also uses a natural language processing engine to analyze user input and generate quantified feature data.

[0915] System Configuration

[0916] Hardware: Servers (e.g. AWS EC2), end-user smartphones

[0917] Software: Natural Language Processing (e.g., TensorFlow, spaCy), Database (e.g., MySQL), Backend (e.g., Python, Django), Frontend (e.g., React Native)

[0918] Registering a user profile

[0919] The server receives the data entered by the user in the new registration form and stores it in a database. The user enters their name, age, gender, email address, and ideal cuisine and restaurant characteristics (e.g., likes spicy food, likes Japanese food).

[0920] Analysis of food and restaurant feature data

[0921] The server analyzes the registered profile data using a natural language processing engine (such as TensorFlow or spaCy) to extract characteristic keywords, and stores the analysis results in a database as numerical data.

[0922] Compatibility Score Calculation

[0923] The server periodically uses the user data and feature data stored in the database to run a matching algorithm, comparing each user's features with the restaurant's characteristics, scoring commonalities and generating a list of optimal restaurants.

[0924] Notification of matching results

[0925] The server stores the generated restaurant list (top 5 restaurants) in a database and prepares to notify the user. When a registered user logs in to the app, the device displays the matching results page and provides basic information about the suggested restaurants (restaurant name, address, and cuisine characteristics).

[0926] Message sending and receiving function

[0927] The device allows users to read reviews of restaurants they like from the generated list and send and receive messages with other users. The server stores these messages in a database and notifies other users when a new message arrives.

[0928] Specific examples

[0929] Example of user profile registration

[0930] When a user registers for the app, they enter their name: Taro, age: 30, gender: male, email address: taro@example.com, ideal food and restaurant characteristics: I like spicy food, I like Japanese food.

[0931] Specific examples of feature data analysis

[0932] The server analyzes the input features "I like spicy food" and "I like Japanese food" using a natural language processing engine and stores each as numerical data in a database (e.g., "I like spicy food" = 0.9, "I like Japanese food" = 0.8).

[0933] Prompt Sentence Examples

[0934] "Kind, loves movies, loves Japanese food"

[0935] Using this prompt, the user's preferences can be quantified and the most suitable restaurant can be suggested.

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

[0937] Step 1: User Registration

[0938] The server receives the data entered by the user into the new registration form. Specifically, the server receives the user's name, age, gender, email address, ideal cuisine, and restaurant characteristics in JSON format and stores them in a database. At that time, a natural language processing engine (e.g., TensorFlow, spaCy) is used to extract characteristic keywords and convert them into numerical data (e.g., "spicy" = 0.9, "Japanese food" = 0.8). This converted data is also stored in the database.

[0939] Input: User profile data (name, age, gender, email address, ideal cuisine and restaurant characteristics)

[0940] Output: User information and feature data stored in a database

[0941] Step 2: Analyze feature data

[0942] The server uses a natural language processing engine to analyze the characteristics of the registered profile data. The analyzed characteristics are stored in a database as numerical data. This provides common characteristic information required for calculations.

[0943] Input: User profile data

[0944] Output: quantified feature data

[0945] Step 3: Calculate your compatibility score

[0946] The server periodically executes a batch job to retrieve user data and feature data stored in the database. The feature data of each user is compared with the characteristic information of all restaurants to calculate a compatibility score. Based on the score calculation algorithm, the commonalities are quantified and a list of the most suitable restaurants is generated.

[0947] Input: Customer data and restaurant characteristics information

[0948] Output: A list of the best restaurants for each user

[0949] Step 4: Notification of match results

[0950] The server stores the generated restaurant list (e.g., the top five restaurants) in a database. When the user logs in to the app, the device displays a matching results page, which shows basic information about the suggested restaurants (such as restaurant name, address, and cuisine characteristics).

[0951] Input: A list of restaurants that are best suited for each user

[0952] Output: Matching results notified to the user

[0953] Step 5: Sending and receiving messages

[0954] The terminal provides a function to read reviews of restaurants that the user likes from the restaurant list that the user created. The user can send and receive messages with other users. The server stores the sent messages in a database and notifies other users when a new message arrives.

[0955] Input: Message from user

[0956] Output: Messages sent and received, messages stored in the database

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

[0958] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. This system registers the user's profile data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a means of communication for sending and receiving messages between the candidates, and by combining it with an emotion engine, it can recognize the user's emotions and optimize the matching process.

[0959] User Registration

[0960] Device:

[0961] When a user accesses the service and opens the homepage, a login button and a new registration button are displayed. When the user clicks the "New Registration" button, a user registration form is displayed.

[0962] User:

[0963] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values, etc.) in the form and click the "Register" button.

[0964] Device:

[0965] The entered user information is converted to JSON format and sent to the server.

[0966] server:

[0967] The received data is temporarily stored. The "ideal partner image" is analyzed using a natural language processing engine to extract characteristic keywords. The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8). The user information and characteristic data are then stored in a database.

[0968] Matching process and emotion engine usage

[0969] server:

[0970] Periodically, a batch job is run to retrieve all user information in the database, and then an algorithm is run to compare each user's ideal partner characteristics with the actual data of all other users.

[0971] The commonalities between each user pair are calculated as a score (e.g., if the commonalities are "kind" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on the calculated scores, a list of compatible candidates is generated for each user.

[0972] Furthermore, an emotion engine is used to recognize emotions from the content of users' messages. The recognized emotion data is then taken into consideration during matching to select more suitable candidates.

[0973] Notification of matching results

[0974] server:

[0975] Build a list of the most compatible candidates (e.g., top 5). Prepare and save the matching result data for each user.

[0976] Device:

[0977] When a user logs in, a matching results page will be displayed. A list of matching candidates will be notified to the user, and basic information (name, age, hobbies, etc.) and photos of each candidate will be displayed.

[0978] Use of messaging features and emotion engines

[0979] User:

[0980] Click the "Send Message" button for the candidate you like from the list of matching candidates. Enter your message in the message input form and click the "Send" button.

[0981] Device:

[0982] Forwards the sent message to the server.

[0983] server:

[0984] Save the message to a database and notify the receiving user (via email or in-app notification) that a new message has arrived.

[0985] It also uses an emotion engine to analyze the emotions in sent messages and provides suggestions to optimize the next communication based on the recognized emotion data.

[0986] Device:

[0987] It displays new messages when the receiving user logs in. It provides a chat interface for both parties to send messages to each other, and retrieves and displays message history from the server.

[0988] Specific examples

[0989] Example of user registration

[0990] When the device is accessed for the first time, it displays a user registration form, and the user enters "Name: Taro, Age: 30, Gender: Male, Email address: taro@example.com, Ideal partner: A kind woman who likes movies." The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[0991] Specific example of matching process

[0992] The server runs a batch job, retrieves all user data, and calculates the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities). A score is calculated based on the commonalities, and an emotion engine is used to consider emotional data to select the candidate with the highest score.

[0993] Specific examples of notifications

[0994] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[0995] Messaging Examples

[0996] The user selects Hanako from the list of candidates and enters the message "Hello, this is Taro. I heard you like movies, so I'm messaging you!" The device forwards the message to the server, which notifies Hanako of the new message. The emotion engine recognizes the emotion of the message and stores that data. From the next time onwards, suggestions are provided that take the emotion data into account. The device displays the message to Hanako and provides a reply function.

[0997] The processing flow will be explained below.

[0998] Program processing steps

[0999] Step 1: User Registration

[1000] 1. Device:

[1001] Displays the homepage and provides login and registration buttons.

[1002] When the user clicks the "New Registration" button, a user registration form is displayed.

[1003] 2. User:

[1004] Enter your name, age, gender, email address, and ideal partner (personality, hobbies, values, etc.) in the form.

[1005] Click the "Register" button.

[1006] 3. Terminal:

[1007] The entered user information is converted to JSON format and sent to the server.

[1008] 4. Server:

[1009] Temporarily saves received data.

[1010] The natural language processing engine analyzes the "ideal partner image" and extracts characteristic keywords.

[1011] The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8).

[1012] Store user information and feature data in a database.

[1013] Step 2: Matching process and using the emotion engine

[1014] 1. Server:

[1015] Periodically run a batch job to retrieve all user information in the database.

[1016] It runs an algorithm that compares the characteristics of each user's ideal partner with the real data of all other users.

[1017] 2. Server:

[1018] The commonality between each user pair is calculated as a score (e.g., if the commonality "kindness" = 0.9 and the commonality "likes movies" = 0.8, the total score = 1.7).

[1019] Based on the calculated score, a list of compatible candidates is generated for each user.

[1020] Furthermore, an emotion engine is used to recognize emotions from the content of the user's message.

[1021] The recognized emotion data is used to take into consideration during matching to select more suitable candidates.

[1022] Step 3: Notification of match results

[1023] 1. Server:

[1024] Build a list of the most compatible candidates (e.g., top 5).

[1025] Prepare and store matching result data for each user.

[1026] 2. Terminal:

[1027] When a user logs in, a matching results page will be displayed.

[1028] The user is notified of a list of matching candidates, and basic information (name, age, hobbies, etc.) and a photo of each candidate are displayed.

[1029] Step 4: Use messaging and emotion engines

[1030] 1. User:

[1031] Click the "Send Message" button for the candidate you like from the list of matching candidates.

[1032] Enter your message in the message input form and click the "Send" button.

[1033] 2. Terminal:

[1034] Forwards the sent message to the server.

[1035] 3. Server:

[1036] Save the message in the database.

[1037] Notify the receiving user that a new message has arrived (via email or in-app notification).

[1038] It also uses an emotion engine to analyze the emotions in sent messages and provides suggestions to optimize the next communication based on the recognized emotion data.

[1039] 4. Terminal:

[1040] Displays new messages when the receiving user logs in.

[1041] It provides a chat interface for both parties to send messages to each other.

[1042] Retrieve and display message history from the server.

[1043] Specific examples

[1044] Step 1 example

[1045] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[1046] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[1047] Step 2: Example

[1048] The server runs a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities).

[1049] A score is calculated based on commonalities, and then an emotion engine is used to take emotional data into account to select the candidate with the highest score.

[1050] Step 3 example

[1051] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[1052] Step 4: Example

[1053] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[1054] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[1055] It uses an emotion engine to recognize the emotion of the message and stores that data as well.

[1056] The system will provide suggestions that take emotional data into account in future messaging.

[1057] The device displays the message to Hanako and provides a reply function.

[1058] Example 2

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

[1060] Conventional matching systems have the problem of being unable to accurately analyze a user's ideal partner and present appropriate candidates. Furthermore, they lack the means to support communication between candidates and promote smooth relationship building, in addition to generating and notifying candidate lists. Furthermore, because they are unable to match users based on their emotions, potential compatibility may not be fully realized.

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

[1062] In this invention, the server includes means for registering user attribute data, means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data, means for calculating compatibility scores and generating a list of multiple candidates using the user data and feature data saved in the database, means for notifying the user of the candidate list, means for providing communication means for sending and receiving information to and from candidates selected from the candidate list, and means for analyzing emotional data in the sent and received information using an emotion analysis engine and optimizing the matching process. This makes it possible to accurately analyze the user's ideal partner image, present the most suitable candidates, and optimize communication taking the emotional data into consideration.

[1063] "User" refers to an individual who uses this system, registers profile data, and receives matching services.

[1064] "Attribute data" refers to information about users provided by users, such as their name, age, gender, email address, and ideal partner image.

[1065] "Natural language processing" refers to the technology of analyzing text data provided by users and extracting meaning and characteristics from it.

[1066] "Feature data" refers to data that quantifies information about an ideal partner extracted through natural language processing.

[1067] "Database" refers to a system for storing user data and characteristic data and for searching and updating them as needed.

[1068] "Compatibility score" refers to the score calculated by comparing a user's ideal partner with the data of other users.

[1069] "Candidate List" refers to a list of potential partners who are compatible with the user, generated based on the compatibility score.

[1070] "Communication means" refers to means for sending and receiving information such as messages between users.

[1071] "Sentiment analysis engine" refers to an analytical device or software that analyzes the content of a message and recognizes the emotions contained therein.

[1072] "Optimization" refers to a method or process for maximizing the efficiency and effectiveness of the matching process and communication, taking into account emotional data, etc.

[1073] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. This system registers the user's attribute data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a means of communication for sending and receiving information between the users and the candidates. By combining this with an emotion analysis engine, the system can recognize the user's emotions and optimize the matching process.

[1074] User Registration

[1075] Device:

[1076] When a user accesses the service and opens the homepage, a login button and a new registration button are displayed. When the user clicks the "New Registration" button, a user registration form is displayed.

[1077] User:

[1078] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values) in the form and click the "Register" button. As a concrete example, a user enters "Name: Taro, Age: 30, Gender: Male, Email address: taro@example.com, Ideal partner: Kind woman who likes movies."

[1079] Device:

[1080] The entered user information is converted to JSON format and sent to the server.

[1081] server:

[1082] The received data is temporarily stored. The "ideal partner" is analyzed using a natural language processing engine (e.g., SpaCy or BERT) to extract characteristic keywords. The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8). The user information and characteristic data are then stored in a database.

[1083] Matching process and emotion engine usage

[1084] server:

[1085] Periodically, a batch job is run to retrieve all user information in the database. An algorithm is run to compare the characteristics of each user's ideal partner with the actual data of all other users. The commonalities between each user pair are calculated as a score (e.g., if the commonalities are "kind" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on the calculated scores, a list of compatible candidates is generated for each user.

[1086] Furthermore, a sentiment analysis engine (e.g., Microsoft Azure's Text Analytics API) is used to recognize emotions from the content of users' messages. The recognized emotional data is then taken into consideration during matching to select more suitable candidates.

[1087] Notification of matching results

[1088] server:

[1089] Build a list of the most compatible candidates (e.g., top 5). Prepare and save the matching result data for each user.

[1090] Device:

[1091] When a user logs in, a matching results page is displayed. The user is notified of a list of matching candidates, and basic information (name, age, hobbies, etc.) and photos of each candidate are displayed. As a specific example, the server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobbies: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[1092] Use of messaging features and emotion engines

[1093] User:

[1094] Click the "Send Message" button for the candidate you like from the list of matching candidates. Enter a message in the message input form and click the "Send" button. For example, a user might enter "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[1095] Device:

[1096] Forwards the sent message to the server.

[1097] server:

[1098] It stores messages in a database, notifies the receiving user of new messages (via email or in-app notification), and uses a sentiment analysis engine to analyze the sentiment of the message and provide suggestions to optimize the next communication based on the recognized sentiment data.

[1099] Device:

[1100] It displays new messages when the receiving user logs in. It provides a chat interface for both parties to send messages to each other, and retrieves and displays message history from the server.

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

[1102] Step 1:

[1103] The user fills out the registration form

[1104] explanation:

[1105] A user accesses the system's homepage and clicks the "New Registration" button. A registration form is then displayed. The user enters their name, age, gender, email address, and ideal partner profile (personality, appearance, hobbies, and values).

[1106] input:

[1107] User inputs name, age, gender, email address, and ideal partner image

[1108] output:

[1109] User-entered data

[1110] Specific behavior:

[1111] A user enters "Name: Taro, Age: 30, Gender: Male, Email address: taro@example.com, Ideal partner: Kind woman who likes movies."

[1112] Step 2:

[1113] The device sends user input to the server

[1114] explanation:

[1115] The device converts the data entered in the registration form into JSON format and sends the converted data to the server using an HTTP POST request.

[1116] input:

[1117] User-entered data

[1118] output:

[1119] JSON format data

[1120] Specific behavior:

[1121] The device will generate JSON data like this:

[1122] json

[1123] {

[1124] "Name": "Taro",

[1125] "Age": 30,

[1126] "Gender": "Male",

[1127] "Email address": "taro@example.com",

[1128] "Ideal partner": "A kind woman who loves movies"

[1129] }

[1130] POST the converted data to https: / / example.com / api / register.

[1131] Step 3:

[1132] The server processes the received data and stores it in a database

[1133] explanation:

[1134] The server parses the received JSON data. It uses a natural language processing engine (e.g., SpaCy or BERT) to analyze the "ideal partner" field and extracts characteristic keywords. It converts these characteristics into numerical values, e.g., "kind" = 0.9, "likes movies" = 0.8. It then stores these values ​​in a database along with the overall user data.

[1135] input:

[1136] User data in JSON format

[1137] output:

[1138] User information and feature data stored in a database

[1139] Specific behavior:

[1140] The server does the following:

[1141] 1. Parse the JSON data.

[1142] 2. Use a natural language processing engine to extract characteristic keywords such as "kind" and "likes movies."

[1143] 3. Quantify the characteristic keywords.

[1144] 4. Store user information and feature data in a database.

[1145] Step 4:

[1146] The server runs a batch job to retrieve the user data

[1147] explanation:

[1148] A scheduled batch job runs at regular intervals to retrieve all user data from the database.

[1149] input:

[1150] All user data stored in the database

[1151] output:

[1152] All user data obtained

[1153] Specific behavior:

[1154] The server periodically runs a batch job to retrieve all user information from the database.

[1155] Step 5:

[1156] The server calculates compatibility scores and generates a candidate list.

[1157] explanation:

[1158] Based on the acquired user data, an algorithm is run to compare each user's ideal partner image with the data of all other users. The more commonalities there are, the higher the compatibility score is calculated, and a list of compatible candidates is generated for each user.

[1159] input:

[1160] All user data

[1161] output:

[1162] Candidate list for each user

[1163] Specific behavior:

[1164] The server does the following:

[1165] 1. Compare each user's ideal partner profile with all other user data.

[1166] 2. The score is calculated so that the more commonalities there are, the higher the score.

[1167] 3. Generate a list of compatible candidates for each user.

[1168] Step 6:

[1169] The server uses a sentiment analysis engine to optimize matching.

[1170] explanation:

[1171] The content of the messages is analyzed to extract the emotional data contained within them. A sentiment analysis engine is used to recognize the sentiment of the messages, and this data is fed back into the matching process to select more suitable candidates.

[1172] input:

[1173] Message content

[1174] output:

[1175] Emotional Data

[1176] Specific behavior:

[1177] The server does the following:

[1178] 1. Input the message into the sentiment analysis engine.

[1179] 2. Obtain emotional data using a sentiment analysis engine.

[1180] 3. Use sentiment data to optimize the matching process.

[1181] Step 7:

[1182] The server builds a list of candidates and stores it in a database

[1183] explanation:

[1184] A list of the most compatible candidates is constructed and the matching result data for each user is stored in a database.

[1185] input:

[1186] List of candidates with high compatibility scores

[1187] output:

[1188] Matching result data stored in the database

[1189] Specific behavior:

[1190] The server does the following:

[1191] 1. Build a shortlist based on compatibility scores.

[1192] 2. Save the matching result data in the database.

[1193] Step 8:

[1194] The device notifies the user of the matching results

[1195] explanation:

[1196] When a user logs in, the matching results are retrieved from the server and displayed on the homepage. A list of candidates is displayed, along with basic information and photos of each candidate.

[1197] input:

[1198] Matching result data stored in the database

[1199] output:

[1200] A list of matching candidates displayed on the screen

[1201] Specific behavior:

[1202] The device will:

[1203] 1. The user logs in.

[1204] 2. Get the matching results from the server.

[1205] 3. Display a list of matching candidates, along with basic information and photos of each candidate.

[1206] Step 9:

[1207] The user types and sends a message

[1208] explanation:

[1209] Select a specific candidate from the list of matching candidates, enter a message, and click the "Send" button.

[1210] input:

[1211] A message entered by the user

[1212] output:

[1213] Message data to be sent

[1214] Specific behavior:

[1215] The user types, "Hi, I'm Taro. I heard you like movies, so I'm messaging you!"

[1216] Step 10:

[1217] The device forwards the message to the server

[1218] explanation:

[1219] The input message is converted back to JSON format for transmission to the server and sent using an HTTP request.

[1220] input:

[1221] A message entered by the user

[1222] output:

[1223] Message data in JSON format

[1224] Specific behavior:

[1225] The device generates the following JSON data and sends it to the server:

[1226] json

[1227] {

[1228] "Sender": "Taro",

[1229] "Recipient": "Hanako",

[1230] "Message": "Hello, I'm Taro. I heard you like movies, so I messaged you!"

[1231] }

[1232] Step 11:

[1233] The server notifies the receiving user and parses the message.

[1234] explanation:

[1235] The message is saved in a database, the receiving user is notified that a new message has arrived, and the message content is analyzed using an emotion analysis engine, and the emotional data is saved for use in the next communication.

[1236] input:

[1237] Message data sent

[1238] output:

[1239] Notifications sent to the receiving user and stored emotion data

[1240] Specific behavior:

[1241] The server does the following:

[1242] 1. Save the message in the database.

[1243] 2. Send a notification to the recipient user.

[1244] 3. The sentiment analysis engine analyzes the sentiment of the message and stores the data.

[1245] Step 12:

[1246] The device displays the new message to the receiving user.

[1247] explanation:

[1248] When the receiving user logs in, it displays new messages and provides reply functionality.

[1249] input:

[1250] New messages notified

[1251] output:

[1252] New on-screen messaging and reply features

[1253] Specific behavior:

[1254] The device will:

[1255] 1. The receiving user logs in.

[1256] 2. View new messages.

[1257] 3. Provide a reply function.

[1258] (Application example 2)

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

[1260] Conventional matching systems sometimes had difficulty proposing suitable candidates and products based on users' preferences and tendencies. Additionally, they lacked a mechanism to understand the emotions expressed in messages sent by users through the system and provide optimal support accordingly, which resulted in a lack of improvement in the user experience.

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

[1262] In this invention, the server includes means for registering user identification information, means for analyzing the ideal target image provided by the user using natural language processing and saving it as feature data, means for calculating an evaluation score using the user data and feature data saved in the database and generating multiple recommendation lists, means for notifying the user of the recommendation lists, means for providing a communication means for sending and receiving messages to targets selected from the recommendation lists, and means for analyzing the emotions in the messages and providing optimal support, thereby making it possible to suggest suitable candidates and products to the user and provide optimal support according to their emotions.

[1263] "User" refers to an individual who uses the system to register profile data and receive matching and product recommendations.

[1264] "Identification information" is data used to identify an individual user, and often includes basic information such as name and email address.

[1265] "Natural language processing" is a set of techniques that allow computers to understand human language, and involves analyzing text data and extracting features.

[1266] "Feature data" is data that quantifies or categorizes the user's ideal target image, and is used as a basis for matching and recommendations.

[1267] The "evaluation score" is a numerical representation of the compatibility between the user's characteristic data and the target data, and is used to generate a recommendation list.

[1268] A "recommended list" is a list of candidates or products provided to a user, selected based on compatibility and preferences.

[1269] "Notification" is a means of notifying users of the contents of a recommendation list or the arrival of a message.

[1270] "Communication means" refers to the technical means for sending and receiving messages between users, and is realized via the Internet or applications.

[1271] "Sentiment analysis" is a technology that uses natural language processing to analyze the emotions in messages sent by users and extract emotional data.

[1272] "Support" refers to the act of providing appropriate advice and support regarding users' messages and actions based on data obtained through sentiment analysis.

[1273] This invention is based on an AI-based system that provides optimal support to users by registering user identification information, generating feature data using natural language processing, calculating evaluation scores, generating and notifying recommendation lists, and analyzing message sentiment.

[1274] Specifically, this system includes a server, a terminal, and a means of communication between users. The main processing steps and the hardware and software used are shown below.

[1275] First, the server has the function of receiving and registering identification information from users. This identification information includes basic data such as name and email address. When a user registers, the data entered through the terminal is sent to the server and saved in JSON format.

[1276] The server then analyzes the ideal target image entered by the user using a natural language processing (NLP) engine. This analysis uses open-source NLP tools such as "NLTK" and "SpaCy." The analyzed data is quantified as feature data and stored in a database.

[1277] The server periodically runs a batch job to retrieve all user data and feature data stored in the database. Based on each user's feature data, it uses scikit-learn's TfidfVectorizer and cosine_similarity to calculate an evaluation score. This generates and stores multiple recommendation lists.

[1278] When a user logs in to their device, the server notifies them of the generated recommendation list, which includes the best candidates based on the user's preferences and rating scores. The notification is made on a web page or mobile application, and the contents of the recommendation list are displayed.

[1279] Furthermore, it provides a real-time communication means for sending and receiving messages between users. Sent messages are transferred to the server and stored in a database. At the same time, the message content is analyzed using an emotion analysis engine (e.g., TextBlob), and the identified emotion data is stored.

[1280] As a specific example, if a user inputs "a woman who loves movies" as their ideal partner, the system will quantify the characteristic "movies" and display a list of recommended partners with similar characteristics. Furthermore, if a user sends a message saying, "Tell me more about this product," the system will use a sentiment analysis engine to distinguish whether the message is positive or negative, and provide the most appropriate support accordingly. For example, a positive message will display a "detailed product description," while a negative message will display "problem-solving guidance."

[1281] Example prompt sentence:

[1282] "Show us how to recommend products based on user preferences."

[1283] "Please explain how to analyze the sentiment of a user's message to provide optimal support."

[1284] As described above, this system provides optimal recommendations and support that take into account the user's preferences and emotions, thereby improving the user experience.

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

[1286] Step 1:

[1287] The user accesses the registration page using a device and enters identification information (name, email address, etc.) and their ideal partner (personality, hobbies, etc.). The entered information is sent to the server in JSON format.

[1288] Input: User's identity and ideal image

[1289] Data processing: Converts text data entered by the user into JSON format

[1290] Output: Data sent to the server in JSON format

[1291] Step 2:

[1292] The server parses the received JSON data and extracts the user's identity and ideal target. The ideal target is analyzed using a natural language processing (NLP) engine (e.g., NLTK, SpaCy) and quantified as feature data. This feature data and identity are then stored in a database.

[1293] Input: JSON formatted identity and ideal target image

[1294] Data processing: Text analysis and quantification using an NLP engine

[1295] Output: Feature data and identification information stored in a database

[1296] Step 3:

[1297] The server periodically runs a batch job to retrieve all user data and feature data from the database. Using the retrieved data, it calculates a rating score for each user along with the data of other users and products. This rating score is calculated using TfidfVectorizer and cosine_similarity (scikit-learn).

[1298] Input: All user data and feature data in the database

[1299] Data processing: Vectorization by TfidfVectorizer and scoring by cosine_similarity

[1300] Output: Rating score for each user

[1301] Step 4:

[1302] The server generates multiple recommendation lists for each user based on the evaluation scores, sorting the candidates in descending order of evaluation score, and stores the lists in a database.

[1303] Input: Rating score

[1304] Data processing: Generate a list based on the evaluation scores

[1305] Output: Recommendation list

[1306] Step 5:

[1307] When a user logs in to their device, the server sends the recommended list to the user's device. Information on the recommended candidates is displayed, and the user can select the candidates and products they want.

[1308] Input: Recommendation List

[1309] Data processing: Get and notify the recommendation list

[1310] Output: Recommendation list displayed on the user's device

[1311] Step 6:

[1312] The user selects a candidate from the recommended list and sends a message. The device forwards the message to the server, which stores it in a database. The server also uses a sentiment analysis engine (TextBlob) to identify the sentiment of the message and optimizes the next communication based on the results.

[1313] Input: The message the user sends

[1314] Data processing: Extracting emotional data using a sentiment analysis engine

[1315] Output: Sentiment analysis results and saved messages

[1316] Step 7:

[1317] The server considers the emotional data of the message and provides optimal support, for example, providing detailed explanations for positive messages and problem-solving guidance for negative messages, thereby improving user satisfaction.

[1318] Input: Sentiment analysis results

[1319] Data processing: Selection of support content

[1320] Output: Optimal support message for the user

[1321] The above are the specific processing steps of the system that realizes the application example.

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

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

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

[1325] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1338] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. This system registers the user's profile data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a communication means for sending and receiving messages between candidates. The specific operation of this system is described below.

[1339] User Registration

[1340] Device:

[1341] When a user accesses the service and opens the homepage, a login button and a new registration button are displayed. When the user clicks the "New Registration" button, a user registration form is displayed.

[1342] User:

[1343] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values, etc.) in the form and click the "Register" button.

[1344] Device:

[1345] The entered user information is sent to the server in JSON format.

[1346] server:

[1347] The received data is temporarily stored, and characteristic keywords are extracted from the "ideal partner image" using a natural language processing engine and converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8, etc.). The user information and extracted characteristic data are then stored in a database.

[1348] Matching process

[1349] server:

[1350] Periodically, a batch job is run to retrieve all user information in the database, and then an algorithm is run to compare each user's ideal partner characteristics with the real data of all other users (e.g., personality, hobbies, values).

[1351] server:

[1352] The commonalities between each user pair are calculated as a score (e.g., if the commonalities "kindness" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on these scores, a list of the most compatible matching candidates is created for each user.

[1353] Notification of matching results

[1354] server:

[1355] Build a list of the most compatible candidates (e.g., top 5 candidates) and store it in a database. Generate matching results for each user and prepare to notify them sequentially.

[1356] Device:

[1357] Registered users are asked to log in and the matching results page is displayed. A list of matching candidates is notified to the user, and basic information (name, age, hobbies, etc.) and photos of each candidate are displayed.

[1358] Messaging Features

[1359] User:

[1360] Click the "Send a message" button for the candidate you like from the list of matching candidates, enter your message in the message input form, and click the "Send" button.

[1361] Device:

[1362] Forwards the sent message to the server.

[1363] server:

[1364] Save the message to a database and notify the receiving user that a new message has arrived (via email or in-app notification).

[1365] Device:

[1366] When the receiving user logs in, it displays new messages. It provides a chat interface for both parties to send and receive messages, and retrieves and displays the message history from the server.

[1367] (Example)

[1368] Example of user registration

[1369] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[1370] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[1371] Specific example of matching process

[1372] The server executes a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities). A score is calculated based on the commonalities, and the candidate with the highest score is selected.

[1373] Specific examples of notifications

[1374] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[1375] Messaging Examples

[1376] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[1377] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[1378] The device displays the message to Hanako and provides a reply function.

[1379] The processing flow will be explained below.

[1380] Program processing steps

[1381] Step 1: User Registration

[1382] 1. Device:

[1383] Display the homepage and display the login and new registration buttons.

[1384] When the user clicks the "New Registration" button, a user registration form is displayed.

[1385] 2. User:

[1386] Enter your name, age, gender, email address, and ideal partner (personality, hobbies, values, etc.) in the user registration form.

[1387] Click the "Register" button.

[1388] 3. Terminal:

[1389] The entered user information is converted to JSON format and sent to the server.

[1390] 4. Server:

[1391] Temporarily saves received data.

[1392] The natural language processing engine analyzes the "ideal partner image" and extracts characteristic keywords.

[1393] The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8).

[1394] Store user information and feature data in a database.

[1395] Step 2: Matching

[1396] 1. Server:

[1397] Periodically run a batch job to retrieve all user information in the database.

[1398] The characteristics of each user's ideal partner are compared with the actual data of all other users.

[1399] 2. Server:

[1400] The commonality between each user pair is calculated as a score (e.g., if the commonality "kindness" = 0.9 and the commonality "likes movies" = 0.8, the total score = 1.7).

[1401] Based on the calculated score, a list of compatible candidates is generated for each user.

[1402] Step 3: Notification of match results

[1403] 1. Server:

[1404] Build a list of the most compatible candidates (e.g., top 5).

[1405] Prepare and store matching result data for each user.

[1406] 2. Terminal:

[1407] When a user logs in, a matching results page will be displayed.

[1408] The user is notified of a list of matching candidates and basic information and photos of each candidate are displayed.

[1409] Step 4: Messaging Features

[1410] 1. User:

[1411] Click the "Send Message" button for the candidate you like from the list of matching candidates.

[1412] Enter your message in the message input form and click the "Send" button.

[1413] 2. Terminal:

[1414] Forwards the sent message to the server.

[1415] 3. Server:

[1416] Save the message in the database.

[1417] Notify the receiving user that a new message has arrived (via email or in-app notification).

[1418] 4. Terminal:

[1419] Displays new messages when the receiving user logs in.

[1420] It provides a chat interface for both parties to send messages to each other.

[1421] Retrieve and display message history from the server.

[1422] Specific examples

[1423] Step 1 example

[1424] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[1425] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[1426] Step 2: Example

[1427] The server runs a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities).

[1428] A score is calculated based on commonalities, and the candidate with the highest score is selected.

[1429] Step 3 example

[1430] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[1431] Step 4: Example

[1432] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[1433] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[1434] The device displays the message to Hanako and provides a reply function.

[1435] Example 1

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

[1437] Conventional matching systems were unable to effectively analyze users' ideal partner profiles, making it difficult to accurately assess compatibility with potential partners. Furthermore, they struggled to smoothly exchange messages with potential partners, leaving a need for an improved user experience.

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

[1439] In this invention, the server includes means for registering user profile data, means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data, means for calculating compatibility scores using the user data and feature data saved in the database and generating multiple candidate lists, means for notifying the user of the candidate list, means for providing communication means for sending and receiving messages with candidates selected from the candidate list, and means for displaying the candidate list and related candidate information on a user interface, thereby enabling users to efficiently meet their ideal partner.

[1440] "User profile data" refers to data that includes personal information and attribute information provided by a user.

[1441] The "ideal partner image" is data that represents the characteristics of the user's desired partner, such as personality, appearance, hobbies, and values.

[1442] "Natural language processing" is a technology that allows computers to understand and interpret human language and extract specific information.

[1443] "Feature data" is data that quantifies the ideal partner image extracted through natural language processing.

[1444] A "database" is a system that systematically stores and manages user profile data and characteristic data.

[1445] A "compatibility score" is an evaluation index calculated based on the commonalities and similarities between the user and the candidate.

[1446] A "candidate list" is a list of multiple suitable partner candidates selected based on their compatibility scores.

[1447] "Notification" is the act of informing the user of results or information.

[1448] "Communication means" refers to the technical means by which messages are sent and received between users.

[1449] A "user interface" is a screen or operating means that allows a user to interact with a system.

[1450] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. The system registers the user's profile data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a communication means for sending and receiving messages between the users and the candidates.

[1451] User Registration

[1452] Device:

[1453] When a user accesses the service, a login button and a new registration button are displayed on the home page. When a user clicks the "New Registration" button, a user registration form is displayed.

[1454] User:

[1455] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values, etc.) in the form and click the "Register" button.

[1456] Device:

[1457] The entered user information is sent to the server in JSON format.

[1458] server:

[1459] The received data is temporarily stored, and characteristic keywords are extracted from the "ideal partner image" using a natural language processing engine and converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8, etc.). The user information and extracted characteristic data are then stored in a database.

[1460] Matching process

[1461] server:

[1462] Periodically, a batch job is run to retrieve all user information in the database, and then an algorithm is run to compare each user's ideal partner characteristics with the real data of all other users (e.g., personality, hobbies, values).

[1463] server:

[1464] The commonalities between each user pair are calculated as a score (e.g., if the commonalities "kindness" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on these scores, a list of the most compatible matching candidates is created for each user.

[1465] Notification of matching results

[1466] server:

[1467] Build a list of the most compatible candidates (e.g., top 5 candidates) and store it in a database. Generate matching results for each user and prepare to notify them sequentially.

[1468] Device:

[1469] Registered users are asked to log in and the matching results page is displayed. A list of matching candidates is notified to the user, and basic information (name, age, hobbies, etc.) and photos of each candidate are displayed.

[1470] Messaging Features

[1471] User:

[1472] Click the "Send a message" button for the candidate you like from the list of matching candidates, enter your message in the message input form, and click the "Send" button.

[1473] Device:

[1474] Forwards the sent message to the server.

[1475] server:

[1476] Save the message to a database and notify the receiving user that a new message has arrived (via email or in-app notification).

[1477] Device:

[1478] When the receiving user logs in, it displays new messages. It provides a chat interface for both parties to send and receive messages, and retrieves and displays the message history from the server.

[1479] Specific examples

[1480] Example of user registration

[1481] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[1482] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[1483] Specific example of matching process

[1484] The server executes a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities). A score is calculated based on the commonalities, and the candidate with the highest score is selected.

[1485] Specific examples of notifications

[1486] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[1487] Messaging Examples

[1488] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[1489] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[1490] The device displays the message to Hanako and provides a reply function.

[1491] Example prompts to input to the generative AI model

[1492] "Please describe your ideal partner:"

[1493] "Please extract common items from user data."

[1494] "View the matching results."

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

[1496] User Registration

[1497] Step 1:

[1498] User visits the sign-up form

[1499] Terminal: A user accesses the service's homepage and clicks the "New Registration" button displayed on the homepage. The input is the user's action (click). The output is the user registration form.

[1500] Step 2:

[1501] Enter and submit user information

[1502] User: Enters name, age, gender, email address, and ideal partner profile (personality, appearance, hobbies, values, etc.) into the form and clicks the "Register" button. User information and ideal partner profile are provided as input, and this data is passed to the terminal. As output, this information is sent to the server in JSON format.

[1503] Step 3:

[1504] The server receives and analyzes the data

[1505] Server: Temporarily stores the received user information and uses a natural language processing engine to extract characteristic keywords from the "ideal partner image" and convert them into numerical data. Specific operations include inputting the received user data (e.g., "kind, likes movies") and outputting characteristic data (e.g., "kind" = 0.9, "likes movies" = 0.8).

[1506] Step 4:

[1507] The server stores user information in a database

[1508] Server: Stores user information along with analyzed feature data in a database. User information and feature data are input, and are stored in a database as output.

[1509] Matching process

[1510] Step 1:

[1511] Running a batch job

[1512] Server: Periodically executes a batch job to retrieve all user information in the database. The input is a trigger for the batch job to be executed periodically, and the output is all user data.

[1513] Step 2:

[1514] Retrieving User Data

[1515] Server: Acquires user data to compare the characteristics of each user's ideal partner with the actual data of all other users. The input contains all user data, and the output extracts data for each user.

[1516] Step 3:

[1517] Comparison with the ideal partner

[1518] Server: Runs an algorithm that compares each user's ideal partner image with other users' data and extracts commonalities. The input is the ideal partner image and other users' data, and the output is the extracted commonalities.

[1519] Step 4:

[1520] Compatibility Score Calculation

[1521] Server: Calculates the commonalities of each user pair as a score and calculates the compatibility score. The input is the extracted commonalities data, and the output is the compatibility score (e.g., if the commonalities are "kind" = 0.9 and "likes movies" = 0.8, the total score is 1.7).

[1522] Step 5:

[1523] Generate a list of match candidates

[1524] Server: Creates a list of best-matching candidates for each user based on their compatibility score. The input is the compatibility score and all user data, and the output is a list of best-matching candidates.

[1525] Notification of matching results

[1526] Step 1:

[1527] Save the best candidates list

[1528] Server: Builds a list of best-match candidates and stores it in a database. The input is the generated list of matching candidates, and the output is stored in a database.

[1529] Step 2:

[1530] Preparing to notify users

[1531] Server: Generates matching results for each user and prepares notifications. The input is the stored list of match candidates, and the output is the prepared notifications.

[1532] Step 3:

[1533] Displaying matching results

[1534] Terminal: When a registered user logs in, the matching results page is displayed and the candidate list is notified to the user. The input is each user's login information, and the output is the matching candidate list and related candidate information.

[1535] Messaging Features

[1536] Step 1:

[1537] User sends a message

[1538] User: Clicks the "Send Message" button of the candidate he likes from the list of match candidates, enters a message and sends it. The input contains the user's message, and the output is the message sent.

[1539] Step 2:

[1540] The server receives and stores the message

[1541] Terminal: Forwards the sent message to the server.

[1542] Server: Stores messages in a database and notifies the receiving user that a new message has arrived. Input is the user's message, output is the message stored and notification sent.

[1543] Step 3:

[1544] Notifying the receiving user

[1545] Terminal: Displays new messages when the receiving user logs in. Inputs are login information and saved messages, and output is the new message.

[1546] Step 4:

[1547] Providing a chat interface and displaying message history

[1548] Terminal: Provides a chat interface for both parties to send messages to each other, and retrieves and displays past message history from the server. The input includes the message history of both parties, and the output displays the messages on the chat screen.

[1549] (Application example 1)

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

[1551] Today's consumers have diverse food preferences and lifestyles, making it difficult to efficiently find restaurants and cuisines that suit them. Finding a suitable restaurant often requires a lot of time and effort, resulting in an unsatisfactory selection. Furthermore, there is a lack of systems that allow users with similar food preferences to exchange reviews and opinions with each other. The purpose of this invention is to solve the above problems and provide an AI matching system that allows users to efficiently find their ideal cuisine and restaurant.

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

[1553] In this invention, the server includes means for registering user profile data, means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data, means for calculating compatibility scores using the user data and feature data saved in the database and generating a list of multiple candidates, means for notifying the user of the candidate list, means for providing communication means for sending and receiving messages between the user and candidates selected from the candidate list, means for inputting the user's favorite dishes and characteristics of dishes they want to eat and suggesting optimal restaurants and dishes based on the input, means for saving the characteristic information of the restaurants and dishes in the database and running a matching algorithm together with user information, and means for notifying the user of the list of restaurant and dish suggestions created by the matching algorithm. This allows users to easily find restaurants and dishes that suit their preferences and to have a richer dining experience by exchanging reviews and impressions with other users who share the same preferences.

[1554] "Profile data" refers to data that includes a user's personal information, preferences, attributes, etc.

[1555] "Ideal partner image" refers to data that expresses the characteristics and conditions of the partner that the user desires.

[1556] "Natural language processing" is a technology that uses computers to analyze and understand the natural language used by humans.

[1557] "Feature data" refers to quantified information about a user's wishes and preferences extracted through natural language processing.

[1558] The "compatibility score" is a numerical representation of the commonalities and degree of similarity between the user's wishes and preferences and the characteristics of the candidate.

[1559] A "candidate list" is a list of multiple candidates that match a user, selected based on their compatibility scores.

[1560] "Communication means" refers to the technology and infrastructure used to send and receive messages and data between users.

[1561] "Favorite dishes" refers to the food or dishes that the user particularly likes.

[1562] A "restaurant" is a business that serves food and drinks to customers.

[1563] "Characteristic information" refers to information about restaurants and their cuisine, including their characteristics, reputation, and menu composition.

[1564] A "matching algorithm" is a calculation method or process for selecting the most suitable candidate based on the user's wishes and preferences.

[1565] The following system configuration is used to implement this invention. The main components include registering user profiles, analyzing food and restaurant feature data, calculating compatibility scores, notifying matching results, and sending and receiving messages. This system also uses a natural language processing engine to analyze user input and generate quantified feature data.

[1566] System Configuration

[1567] Hardware: Servers (e.g. AWS EC2), end-user smartphones

[1568] Software: Natural Language Processing (e.g., TensorFlow, spaCy), Database (e.g., MySQL), Backend (e.g., Python, Django), Frontend (e.g., React Native)

[1569] Registering a user profile

[1570] The server receives the data entered by the user in the new registration form and stores it in a database. The user enters their name, age, gender, email address, and ideal cuisine and restaurant characteristics (e.g., likes spicy food, likes Japanese food).

[1571] Analysis of food and restaurant feature data

[1572] The server analyzes the registered profile data using a natural language processing engine (such as TensorFlow or spaCy) to extract characteristic keywords, and stores the analysis results in a database as numerical data.

[1573] Compatibility Score Calculation

[1574] The server periodically uses the user data and feature data stored in the database to run a matching algorithm, comparing each user's features with the restaurant's characteristics, scoring commonalities and generating a list of optimal restaurants.

[1575] Notification of matching results

[1576] The server stores the generated restaurant list (top 5 restaurants) in a database and prepares to notify the user. When a registered user logs in to the app, the device displays the matching results page and provides basic information about the suggested restaurants (restaurant name, address, and cuisine characteristics).

[1577] Message sending and receiving function

[1578] The device allows users to read reviews of restaurants they like from the generated list and send and receive messages with other users. The server stores these messages in a database and notifies other users when a new message arrives.

[1579] Specific examples

[1580] Example of user profile registration

[1581] When a user registers for the app, they enter their name: Taro, age: 30, gender: male, email address: taro@example.com, ideal food and restaurant characteristics: I like spicy food, I like Japanese food.

[1582] Specific examples of feature data analysis

[1583] The server analyzes the input features "I like spicy food" and "I like Japanese food" using a natural language processing engine and stores each as numerical data in a database (e.g., "I like spicy food" = 0.9, "I like Japanese food" = 0.8).

[1584] Prompt Sentence Examples

[1585] "Kind, loves movies, loves Japanese food"

[1586] Using this prompt, the user's preferences can be quantified and the most suitable restaurant can be suggested.

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

[1588] Step 1: User Registration

[1589] The server receives the data entered by the user into the new registration form. Specifically, the server receives the user's name, age, gender, email address, ideal cuisine, and restaurant characteristics in JSON format and stores them in a database. At that time, a natural language processing engine (e.g., TensorFlow, spaCy) is used to extract characteristic keywords and convert them into numerical data (e.g., "spicy" = 0.9, "Japanese food" = 0.8). This converted data is also stored in the database.

[1590] Input: User profile data (name, age, gender, email address, ideal cuisine and restaurant characteristics)

[1591] Output: User information and feature data stored in a database

[1592] Step 2: Analyze feature data

[1593] The server uses a natural language processing engine to analyze the characteristics of the registered profile data. The analyzed characteristics are stored in a database as numerical data. This provides common characteristic information required for calculations.

[1594] Input: User profile data

[1595] Output: quantified feature data

[1596] Step 3: Calculate your compatibility score

[1597] The server periodically executes a batch job to retrieve user data and feature data stored in the database. The feature data of each user is compared with the characteristic information of all restaurants to calculate a compatibility score. Based on the score calculation algorithm, the commonalities are quantified and a list of the most suitable restaurants is generated.

[1598] Input: Customer data and restaurant characteristics information

[1599] Output: A list of the best restaurants for each user

[1600] Step 4: Notification of match results

[1601] The server stores the generated restaurant list (e.g., the top five restaurants) in a database. When the user logs in to the app, the device displays a matching results page, which shows basic information about the suggested restaurants (such as restaurant name, address, and cuisine characteristics).

[1602] Input: A list of restaurants that are best suited for each user

[1603] Output: Matching results notified to the user

[1604] Step 5: Sending and receiving messages

[1605] The terminal provides a function to read reviews of restaurants that the user likes from the restaurant list that the user created. The user can send and receive messages with other users. The server stores the sent messages in a database and notifies other users when a new message arrives.

[1606] Input: Message from user

[1607] Output: Messages sent and received, messages stored in the database

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

[1609] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. This system registers the user's profile data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a means of communication for sending and receiving messages between the candidates, and by combining it with an emotion engine, it can recognize the user's emotions and optimize the matching process.

[1610] User Registration

[1611] Device:

[1612] When a user accesses the service and opens the homepage, a login button and a new registration button are displayed. When the user clicks the "New Registration" button, a user registration form is displayed.

[1613] User:

[1614] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values, etc.) in the form and click the "Register" button.

[1615] Device:

[1616] The entered user information is converted to JSON format and sent to the server.

[1617] server:

[1618] The received data is temporarily stored. The "ideal partner image" is analyzed using a natural language processing engine to extract characteristic keywords. The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8). The user information and characteristic data are then stored in a database.

[1619] Matching process and emotion engine usage

[1620] server:

[1621] Periodically, a batch job is run to retrieve all user information in the database, and then an algorithm is run to compare each user's ideal partner characteristics with the actual data of all other users.

[1622] The commonalities between each user pair are calculated as a score (e.g., if the commonalities are "kind" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on the calculated scores, a list of compatible candidates is generated for each user.

[1623] Furthermore, an emotion engine is used to recognize emotions from the content of users' messages. The recognized emotion data is then taken into consideration during matching to select more suitable candidates.

[1624] Notification of matching results

[1625] server:

[1626] Build a list of the most compatible candidates (e.g., top 5). Prepare and save the matching result data for each user.

[1627] Device:

[1628] When a user logs in, a matching results page will be displayed. A list of matching candidates will be notified to the user, and basic information (name, age, hobbies, etc.) and photos of each candidate will be displayed.

[1629] Use of messaging features and emotion engines

[1630] User:

[1631] Click the "Send Message" button for the candidate you like from the list of matching candidates. Enter your message in the message input form and click the "Send" button.

[1632] Device:

[1633] Forwards the sent message to the server.

[1634] server:

[1635] Save the message to a database and notify the receiving user (via email or in-app notification) that a new message has arrived.

[1636] It also uses an emotion engine to analyze the emotions in sent messages and provides suggestions to optimize the next communication based on the recognized emotion data.

[1637] Device:

[1638] It displays new messages when the receiving user logs in. It provides a chat interface for both parties to send messages to each other, and retrieves and displays message history from the server.

[1639] Specific examples

[1640] Example of user registration

[1641] When the device is accessed for the first time, it displays a user registration form, and the user enters "Name: Taro, Age: 30, Gender: Male, Email address: taro@example.com, Ideal partner: A kind woman who likes movies." The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[1642] Specific example of matching process

[1643] The server runs a batch job, retrieves all user data, and calculates the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities). A score is calculated based on the commonalities, and an emotion engine is used to consider emotional data to select the candidate with the highest score.

[1644] Specific examples of notifications

[1645] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[1646] Messaging Examples

[1647] The user selects Hanako from the list of candidates and enters the message "Hello, this is Taro. I heard you like movies, so I'm messaging you!" The device forwards the message to the server, which notifies Hanako of the new message. The emotion engine recognizes the emotion of the message and stores that data. From the next time onwards, suggestions are provided that take the emotion data into account. The device displays the message to Hanako and provides a reply function.

[1648] The processing flow will be explained below.

[1649] Program processing steps

[1650] Step 1: User Registration

[1651] 1. Device:

[1652] Displays the homepage and provides login and registration buttons.

[1653] When the user clicks the "New Registration" button, a user registration form is displayed.

[1654] 2. User:

[1655] Enter your name, age, gender, email address, and ideal partner (personality, hobbies, values, etc.) in the form.

[1656] Click the "Register" button.

[1657] 3. Terminal:

[1658] The entered user information is converted to JSON format and sent to the server.

[1659] 4. Server:

[1660] Temporarily saves received data.

[1661] The natural language processing engine analyzes the "ideal partner image" and extracts characteristic keywords.

[1662] The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8).

[1663] Store user information and feature data in a database.

[1664] Step 2: Matching process and using the emotion engine

[1665] 1. Server:

[1666] Periodically run a batch job to retrieve all user information in the database.

[1667] It runs an algorithm that compares the characteristics of each user's ideal partner with the real data of all other users.

[1668] 2. Server:

[1669] The commonality between each user pair is calculated as a score (e.g., if the commonality "kindness" = 0.9 and the commonality "likes movies" = 0.8, the total score = 1.7).

[1670] Based on the calculated score, a list of compatible candidates is generated for each user.

[1671] Furthermore, an emotion engine is used to recognize emotions from the content of the user's message.

[1672] The recognized emotion data is used to take into consideration during matching to select more suitable candidates.

[1673] Step 3: Notification of match results

[1674] 1. Server:

[1675] Build a list of the most compatible candidates (e.g., top 5).

[1676] Prepare and store matching result data for each user.

[1677] 2. Terminal:

[1678] When a user logs in, a matching results page will be displayed.

[1679] The user is notified of a list of matching candidates, and basic information (name, age, hobbies, etc.) and a photo of each candidate are displayed.

[1680] Step 4: Use messaging and emotion engines

[1681] 1. User:

[1682] Click the "Send Message" button for the candidate you like from the list of matching candidates.

[1683] Enter your message in the message input form and click the "Send" button.

[1684] 2. Terminal:

[1685] Forwards the sent message to the server.

[1686] 3. Server:

[1687] Save the message in the database.

[1688] Notify the receiving user that a new message has arrived (via email or in-app notification).

[1689] It also uses an emotion engine to analyze the emotions in sent messages and provides suggestions to optimize the next communication based on the recognized emotion data.

[1690] 4. Terminal:

[1691] Displays new messages when the receiving user logs in.

[1692] It provides a chat interface for both parties to send messages to each other.

[1693] Retrieve and display message history from the server.

[1694] Specific examples

[1695] Step 1 example

[1696] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[1697] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[1698] Step 2: Example

[1699] The server runs a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities).

[1700] A score is calculated based on commonalities, and then an emotion engine is used to take emotional data into account to select the candidate with the highest score.

[1701] Step 3 example

[1702] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[1703] Step 4: Example

[1704] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[1705] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[1706] It uses an emotion engine to recognize the emotion of the message and stores that data as well.

[1707] The system will provide suggestions that take emotional data into account in future messaging.

[1708] The device displays the message to Hanako and provides a reply function.

[1709] Example 2

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

[1711] Conventional matching systems have the problem of being unable to accurately analyze a user's ideal partner and present appropriate candidates. Furthermore, they lack the means to support communication between candidates and promote smooth relationship building, in addition to generating and notifying candidate lists. Furthermore, because they are unable to match users based on their emotions, potential compatibility may not be fully realized.

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

[1713] In this invention, the server includes means for registering user attribute data, means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data, means for calculating compatibility scores and generating a list of multiple candidates using the user data and feature data saved in the database, means for notifying the user of the candidate list, means for providing communication means for sending and receiving information to and from candidates selected from the candidate list, and means for analyzing emotional data in the sent and received information using an emotion analysis engine and optimizing the matching process. This makes it possible to accurately analyze the user's ideal partner image, present the most suitable candidates, and optimize communication taking the emotional data into consideration.

[1714] "User" refers to an individual who uses this system, registers profile data, and receives matching services.

[1715] "Attribute data" refers to information about users provided by users, such as their name, age, gender, email address, and ideal partner image.

[1716] "Natural language processing" refers to the technology of analyzing text data provided by users and extracting meaning and characteristics from it.

[1717] "Feature data" refers to data that quantifies information about an ideal partner extracted through natural language processing.

[1718] "Database" refers to a system for storing user data and characteristic data and for searching and updating them as needed.

[1719] "Compatibility score" refers to the score calculated by comparing a user's ideal partner with the data of other users.

[1720] "Candidate List" refers to a list of potential partners who are compatible with the user, generated based on the compatibility score.

[1721] "Communication means" refers to means for sending and receiving information such as messages between users.

[1722] "Sentiment analysis engine" refers to an analytical device or software that analyzes the content of a message and recognizes the emotions contained therein.

[1723] "Optimization" refers to a method or process for maximizing the efficiency and effectiveness of the matching process and communication, taking into account emotional data, etc.

[1724] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. This system registers the user's attribute data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a means of communication for sending and receiving information between the users and the candidates. By combining this with an emotion analysis engine, the system can recognize the user's emotions and optimize the matching process.

[1725] User Registration

[1726] Device:

[1727] When a user accesses the service and opens the homepage, a login button and a new registration button are displayed. When the user clicks the "New Registration" button, a user registration form is displayed.

[1728] User:

[1729] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values) in the form and click the "Register" button. As a concrete example, a user enters "Name: Taro, Age: 30, Gender: Male, Email address: taro@example.com, Ideal partner: Kind woman who likes movies."

[1730] Device:

[1731] The entered user information is converted to JSON format and sent to the server.

[1732] server:

[1733] The received data is temporarily stored. The "ideal partner" is analyzed using a natural language processing engine (e.g., SpaCy or BERT) to extract characteristic keywords. The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8). The user information and characteristic data are then stored in a database.

[1734] Matching process and emotion engine usage

[1735] server:

[1736] Periodically, a batch job is run to retrieve all user information in the database. An algorithm is run to compare the characteristics of each user's ideal partner with the actual data of all other users. The commonalities between each user pair are calculated as a score (e.g., if the commonalities are "kind" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on the calculated scores, a list of compatible candidates is generated for each user.

[1737] Furthermore, a sentiment analysis engine (e.g., Microsoft Azure's Text Analytics API) is used to recognize emotions from the content of users' messages. The recognized emotional data is then taken into consideration during matching to select more suitable candidates.

[1738] Notification of matching results

[1739] server:

[1740] Build a list of the most compatible candidates (e.g., top 5). Prepare and save the matching result data for each user.

[1741] Device:

[1742] When a user logs in, a matching results page is displayed. The user is notified of a list of matching candidates, and basic information (name, age, hobbies, etc.) and photos of each candidate are displayed. As a specific example, the server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobbies: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[1743] Use of messaging features and emotion engines

[1744] User:

[1745] Click the "Send Message" button for the candidate you like from the list of matching candidates. Enter a message in the message input form and click the "Send" button. For example, a user might enter "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[1746] Device:

[1747] Forwards the sent message to the server.

[1748] server:

[1749] It stores messages in a database, notifies the receiving user of new messages (via email or in-app notification), and uses a sentiment analysis engine to analyze the sentiment of the message and provide suggestions to optimize the next communication based on the recognized sentiment data.

[1750] Device:

[1751] It displays new messages when the receiving user logs in. It provides a chat interface for both parties to send messages to each other, and retrieves and displays message history from the server.

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

[1753] Step 1:

[1754] The user fills out the registration form

[1755] explanation:

[1756] A user accesses the system's homepage and clicks the "New Registration" button. A registration form is then displayed. The user enters their name, age, gender, email address, and ideal partner profile (personality, appearance, hobbies, and values).

[1757] input:

[1758] User inputs name, age, gender, email address, and ideal partner image

[1759] output:

[1760] User-entered data

[1761] Specific behavior:

[1762] A user enters "Name: Taro, Age: 30, Gender: Male, Email address: taro@example.com, Ideal partner: Kind woman who likes movies."

[1763] Step 2:

[1764] The device sends user input to the server

[1765] explanation:

[1766] The device converts the data entered in the registration form into JSON format and sends the converted data to the server using an HTTP POST request.

[1767] input:

[1768] User-entered data

[1769] output:

[1770] JSON format data

[1771] Specific behavior:

[1772] The device will generate JSON data like this:

[1773] json

[1774] {

[1775] "Name": "Taro",

[1776] "Age": 30,

[1777] "Gender": "Male",

[1778] "Email address": "taro@example.com",

[1779] "Ideal partner": "A kind woman who loves movies"

[1780] }

[1781] POST the converted data to https: / / example.com / api / register.

[1782] Step 3:

[1783] The server processes the received data and stores it in a database

[1784] explanation:

[1785] The server parses the received JSON data. It uses a natural language processing engine (e.g., SpaCy or BERT) to analyze the "ideal partner" field and extracts characteristic keywords. It converts these characteristics into numerical values, e.g., "kind" = 0.9, "likes movies" = 0.8. It then stores these values ​​in a database along with the overall user data.

[1786] input:

[1787] User data in JSON format

[1788] output:

[1789] User information and feature data stored in a database

[1790] Specific behavior:

[1791] The server does the following:

[1792] 1. Parse the JSON data.

[1793] 2. Use a natural language processing engine to extract characteristic keywords such as "kind" and "likes movies."

[1794] 3. Quantify the characteristic keywords.

[1795] 4. Store user information and feature data in a database.

[1796] Step 4:

[1797] The server runs a batch job to retrieve the user data

[1798] explanation:

[1799] A scheduled batch job runs at regular intervals to retrieve all user data from the database.

[1800] input:

[1801] All user data stored in the database

[1802] output:

[1803] All user data obtained

[1804] Specific behavior:

[1805] The server periodically runs a batch job to retrieve all user information from the database.

[1806] Step 5:

[1807] The server calculates compatibility scores and generates a candidate list.

[1808] explanation:

[1809] Based on the acquired user data, an algorithm is run to compare each user's ideal partner image with the data of all other users. The more commonalities there are, the higher the compatibility score is calculated, and a list of compatible candidates is generated for each user.

[1810] input:

[1811] All user data

[1812] output:

[1813] Candidate list for each user

[1814] Specific behavior:

[1815] The server does the following:

[1816] 1. Compare each user's ideal partner profile with all other user data.

[1817] 2. The score is calculated so that the more commonalities there are, the higher the score.

[1818] 3. Generate a list of compatible candidates for each user.

[1819] Step 6:

[1820] The server uses a sentiment analysis engine to optimize matching.

[1821] explanation:

[1822] The content of the messages is analyzed to extract the emotional data contained within them. A sentiment analysis engine is used to recognize the sentiment of the messages, and this data is fed back into the matching process to select more suitable candidates.

[1823] input:

[1824] Message content

[1825] output:

[1826] Emotional Data

[1827] Specific behavior:

[1828] The server does the following:

[1829] 1. Input the message into the sentiment analysis engine.

[1830] 2. Obtain emotional data using a sentiment analysis engine.

[1831] 3. Use sentiment data to optimize the matching process.

[1832] Step 7:

[1833] The server builds a list of candidates and stores it in a database

[1834] explanation:

[1835] A list of the most compatible candidates is constructed and the matching result data for each user is stored in a database.

[1836] input:

[1837] List of candidates with high compatibility scores

[1838] output:

[1839] Matching result data stored in the database

[1840] Specific behavior:

[1841] The server does the following:

[1842] 1. Build a shortlist based on compatibility scores.

[1843] 2. Save the matching result data in the database.

[1844] Step 8:

[1845] The device notifies the user of the matching results

[1846] explanation:

[1847] When a user logs in, the matching results are retrieved from the server and displayed on the homepage. A list of candidates is displayed, along with basic information and photos of each candidate.

[1848] input:

[1849] Matching result data stored in the database

[1850] output:

[1851] A list of matching candidates displayed on the screen

[1852] Specific behavior:

[1853] The device will:

[1854] 1. The user logs in.

[1855] 2. Get the matching results from the server.

[1856] 3. Display a list of matching candidates, along with basic information and photos of each candidate.

[1857] Step 9:

[1858] The user types and sends a message

[1859] explanation:

[1860] Select a specific candidate from the list of matching candidates, enter a message, and click the "Send" button.

[1861] input:

[1862] A message entered by the user

[1863] output:

[1864] Message data to be sent

[1865] Specific behavior:

[1866] The user types, "Hi, I'm Taro. I heard you like movies, so I'm messaging you!"

[1867] Step 10:

[1868] The device forwards the message to the server

[1869] explanation:

[1870] The input message is converted back to JSON format for transmission to the server and sent using an HTTP request.

[1871] input:

[1872] A message entered by the user

[1873] output:

[1874] Message data in JSON format

[1875] Specific behavior:

[1876] The device generates the following JSON data and sends it to the server:

[1877] json

[1878] {

[1879] "Sender": "Taro",

[1880] "Recipient": "Hanako",

[1881] "Message": "Hello, I'm Taro. I heard you like movies, so I messaged you!"

[1882] }

[1883] Step 11:

[1884] The server notifies the receiving user and parses the message.

[1885] explanation:

[1886] The message is saved in a database, the receiving user is notified that a new message has arrived, and the message content is analyzed using an emotion analysis engine, and the emotional data is saved for use in the next communication.

[1887] input:

[1888] Message data sent

[1889] output:

[1890] Notifications sent to the receiving user and stored emotion data

[1891] Specific behavior:

[1892] The server does the following:

[1893] 1. Save the message in the database.

[1894] 2. Send a notification to the recipient user.

[1895] 3. The sentiment analysis engine analyzes the sentiment of the message and stores the data.

[1896] Step 12:

[1897] The device displays the new message to the receiving user.

[1898] explanation:

[1899] When the receiving user logs in, it displays new messages and provides reply functionality.

[1900] input:

[1901] New messages notified

[1902] output:

[1903] New on-screen messaging and reply features

[1904] Specific behavior:

[1905] The device will:

[1906] 1. The receiving user logs in.

[1907] 2. View new messages.

[1908] 3. Provide a reply function.

[1909] (Application example 2)

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

[1911] Conventional matching systems sometimes had difficulty proposing suitable candidates and products based on users' preferences and tendencies. Additionally, they lacked a mechanism to understand the emotions expressed in messages sent by users through the system and provide optimal support accordingly, which resulted in a lack of improvement in the user experience.

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

[1913] In this invention, the server includes means for registering user identification information, means for analyzing the ideal target image provided by the user using natural language processing and saving it as feature data, means for calculating an evaluation score using the user data and feature data saved in the database and generating multiple recommendation lists, means for notifying the user of the recommendation lists, means for providing a communication means for sending and receiving messages to targets selected from the recommendation lists, and means for analyzing the emotions in the messages and providing optimal support, thereby making it possible to suggest suitable candidates and products to the user and provide optimal support according to their emotions.

[1914] "User" refers to an individual who uses the system to register profile data and receive matching and product recommendations.

[1915] "Identification information" is data used to identify an individual user, and often includes basic information such as name and email address.

[1916] "Natural language processing" is a set of techniques that allow computers to understand human language, and involves analyzing text data and extracting features.

[1917] "Feature data" is data that quantifies or categorizes the user's ideal target image, and is used as a basis for matching and recommendations.

[1918] The "evaluation score" is a numerical representation of the compatibility between the user's characteristic data and the target data, and is used to generate a recommendation list.

[1919] A "recommended list" is a list of candidates or products provided to a user, selected based on compatibility and preferences.

[1920] "Notification" is a means of notifying users of the contents of a recommendation list or the arrival of a message.

[1921] "Communication means" refers to the technical means for sending and receiving messages between users, and is realized via the Internet or applications.

[1922] "Sentiment analysis" is a technology that uses natural language processing to analyze the emotions in messages sent by users and extract emotional data.

[1923] "Support" refers to the act of providing appropriate advice and support regarding users' messages and actions based on data obtained through sentiment analysis.

[1924] This invention is based on an AI-based system that provides optimal support to users by registering user identification information, generating feature data using natural language processing, calculating evaluation scores, generating and notifying recommendation lists, and analyzing message sentiment.

[1925] Specifically, this system includes a server, a terminal, and a means of communication between users. The main processing steps and the hardware and software used are shown below.

[1926] First, the server has the function of receiving and registering identification information from users. This identification information includes basic data such as name and email address. When a user registers, the data entered through the terminal is sent to the server and saved in JSON format.

[1927] The server then analyzes the ideal target image entered by the user using a natural language processing (NLP) engine. This analysis uses open-source NLP tools such as "NLTK" and "SpaCy." The analyzed data is quantified as feature data and stored in a database.

[1928] The server periodically runs a batch job to retrieve all user data and feature data stored in the database. Based on each user's feature data, it uses scikit-learn's TfidfVectorizer and cosine_similarity to calculate an evaluation score. This generates and stores multiple recommendation lists.

[1929] When a user logs in to their device, the server notifies them of the generated recommendation list, which includes the best candidates based on the user's preferences and rating scores. The notification is made on a web page or mobile application, and the contents of the recommendation list are displayed.

[1930] Furthermore, it provides a real-time communication means for sending and receiving messages between users. Sent messages are transferred to the server and stored in a database. At the same time, the message content is analyzed using an emotion analysis engine (e.g., TextBlob), and the identified emotion data is stored.

[1931] As a specific example, if a user inputs "a woman who loves movies" as their ideal partner, the system will quantify the characteristic "movies" and display a list of recommended partners with similar characteristics. Furthermore, if a user sends a message saying, "Tell me more about this product," the system will use a sentiment analysis engine to distinguish whether the message is positive or negative, and provide the most appropriate support accordingly. For example, a positive message will display a "detailed product description," while a negative message will display "problem-solving guidance."

[1932] Example prompt sentence:

[1933] "Show us how to recommend products based on user preferences."

[1934] "Please explain how to analyze the sentiment of a user's message to provide optimal support."

[1935] As described above, this system provides optimal recommendations and support that take into account the user's preferences and emotions, thereby improving the user experience.

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

[1937] Step 1:

[1938] The user accesses the registration page using a device and enters identification information (name, email address, etc.) and their ideal partner (personality, hobbies, etc.). The entered information is sent to the server in JSON format.

[1939] Input: User's identity and ideal image

[1940] Data processing: Converts text data entered by the user into JSON format

[1941] Output: Data sent to the server in JSON format

[1942] Step 2:

[1943] The server parses the received JSON data and extracts the user's identity and ideal target. The ideal target is analyzed using a natural language processing (NLP) engine (e.g., NLTK, SpaCy) and quantified as feature data. This feature data and identity are then stored in a database.

[1944] Input: JSON formatted identity and ideal target image

[1945] Data processing: Text analysis and quantification using an NLP engine

[1946] Output: Feature data and identification information stored in a database

[1947] Step 3:

[1948] The server periodically runs a batch job to retrieve all user data and feature data from the database. Using the retrieved data, it calculates a rating score for each user along with the data of other users and products. This rating score is calculated using TfidfVectorizer and cosine_similarity (scikit-learn).

[1949] Input: All user data and feature data in the database

[1950] Data processing: Vectorization by TfidfVectorizer and scoring by cosine_similarity

[1951] Output: Rating score for each user

[1952] Step 4:

[1953] The server generates multiple recommendation lists for each user based on the evaluation scores, sorting the candidates in descending order of evaluation score, and stores the lists in a database.

[1954] Input: Rating score

[1955] Data processing: Generate a list based on the evaluation scores

[1956] Output: Recommendation list

[1957] Step 5:

[1958] When a user logs in to their device, the server sends the recommended list to the user's device. Information on the recommended candidates is displayed, and the user can select the candidates and products they want.

[1959] Input: Recommendation List

[1960] Data processing: Get and notify the recommendation list

[1961] Output: Recommendation list displayed on the user's device

[1962] Step 6:

[1963] The user selects a candidate from the recommended list and sends a message. The device forwards the message to the server, which stores it in a database. The server also uses a sentiment analysis engine (TextBlob) to identify the sentiment of the message and optimizes the next communication based on the results.

[1964] Input: The message the user sends

[1965] Data processing: Extracting emotional data using a sentiment analysis engine

[1966] Output: Sentiment analysis results and saved messages

[1967] Step 7:

[1968] The server considers the emotional data of the message and provides optimal support, for example, providing detailed explanations for positive messages and problem-solving guidance for negative messages, thereby improving user satisfaction.

[1969] Input: Sentiment analysis results

[1970] Data processing: Selection of support content

[1971] Output: Optimal support message for the user

[1972] The above are the specific processing steps of the system that realizes the application example.

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

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

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

[1976] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1990] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. This system registers the user's profile data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a communication means for sending and receiving messages between candidates. The specific operation of this system is described below.

[1991] User Registration

[1992] Device:

[1993] When a user accesses the service and opens the homepage, a login button and a new registration button are displayed. When the user clicks the "New Registration" button, a user registration form is displayed.

[1994] User:

[1995] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values, etc.) in the form and click the "Register" button.

[1996] Device:

[1997] The entered user information is sent to the server in JSON format.

[1998] server:

[1999] The received data is temporarily stored, and characteristic keywords are extracted from the "ideal partner image" using a natural language processing engine and converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8, etc.). The user information and extracted characteristic data are then stored in a database.

[2000] Matching process

[2001] server:

[2002] Periodically, a batch job is run to retrieve all user information in the database, and then an algorithm is run to compare each user's ideal partner characteristics with the real data of all other users (e.g., personality, hobbies, values).

[2003] server:

[2004] The commonalities between each user pair are calculated as a score (e.g., if the commonalities "kindness" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on these scores, a list of the most compatible matching candidates is created for each user.

[2005] Notification of matching results

[2006] server:

[2007] Build a list of the most compatible candidates (e.g., top 5 candidates) and store it in a database. Generate matching results for each user and prepare to notify them sequentially.

[2008] Device:

[2009] Registered users are asked to log in and the matching results page is displayed. A list of matching candidates is notified to the user, and basic information (name, age, hobbies, etc.) and photos of each candidate are displayed.

[2010] Messaging Features

[2011] User:

[2012] Click the "Send a message" button for the candidate you like from the list of matching candidates, enter your message in the message input form, and click the "Send" button.

[2013] Device:

[2014] Forwards the sent message to the server.

[2015] server:

[2016] Save the message to a database and notify the receiving user that a new message has arrived (via email or in-app notification).

[2017] Device:

[2018] When the receiving user logs in, it displays new messages. It provides a chat interface for both parties to send and receive messages, and retrieves and displays the message history from the server.

[2019] (Example)

[2020] Example of user registration

[2021] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[2022] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[2023] Specific example of matching process

[2024] The server executes a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities). A score is calculated based on the commonalities, and the candidate with the highest score is selected.

[2025] Specific examples of notifications

[2026] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[2027] Messaging Examples

[2028] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[2029] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[2030] The device displays the message to Hanako and provides a reply function.

[2031] The processing flow will be explained below.

[2032] Program processing steps

[2033] Step 1: User Registration

[2034] 1. Device:

[2035] Display the homepage and display the login and new registration buttons.

[2036] When the user clicks the "New Registration" button, a user registration form is displayed.

[2037] 2. User:

[2038] Enter your name, age, gender, email address, and ideal partner (personality, hobbies, values, etc.) in the user registration form.

[2039] Click the "Register" button.

[2040] 3. Terminal:

[2041] The entered user information is converted to JSON format and sent to the server.

[2042] 4. Server:

[2043] Temporarily saves received data.

[2044] The natural language processing engine analyzes the "ideal partner image" and extracts characteristic keywords.

[2045] The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8).

[2046] Store user information and feature data in a database.

[2047] Step 2: Matching

[2048] 1. Server:

[2049] Periodically run a batch job to retrieve all user information in the database.

[2050] The characteristics of each user's ideal partner are compared with the actual data of all other users.

[2051] 2. Server:

[2052] The commonality between each user pair is calculated as a score (e.g., if the commonality "kindness" = 0.9 and the commonality "likes movies" = 0.8, the total score = 1.7).

[2053] Based on the calculated score, a list of compatible candidates is generated for each user.

[2054] Step 3: Notification of match results

[2055] 1. Server:

[2056] Build a list of the most compatible candidates (e.g., top 5).

[2057] Prepare and store matching result data for each user.

[2058] 2. Terminal:

[2059] When a user logs in, a matching results page will be displayed.

[2060] The user is notified of a list of matching candidates and basic information and photos of each candidate are displayed.

[2061] Step 4: Messaging Features

[2062] 1. User:

[2063] Click the "Send Message" button for the candidate you like from the list of matching candidates.

[2064] Enter your message in the message input form and click the "Send" button.

[2065] 2. Terminal:

[2066] Forwards the sent message to the server.

[2067] 3. Server:

[2068] Save the message in the database.

[2069] Notify the receiving user that a new message has arrived (via email or in-app notification).

[2070] 4. Terminal:

[2071] Displays new messages when the receiving user logs in.

[2072] It provides a chat interface for both parties to send messages to each other.

[2073] Retrieve and display message history from the server.

[2074] Specific examples

[2075] Step 1 example

[2076] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[2077] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[2078] Step 2: Example

[2079] The server runs a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities).

[2080] A score is calculated based on commonalities, and the candidate with the highest score is selected.

[2081] Step 3 example

[2082] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[2083] Step 4: Example

[2084] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[2085] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[2086] The device displays the message to Hanako and provides a reply function.

[2087] Example 1

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

[2089] Conventional matching systems were unable to effectively analyze users' ideal partner profiles, making it difficult to accurately assess compatibility with potential partners. Furthermore, they struggled to smoothly exchange messages with potential partners, leaving a need for an improved user experience.

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

[2091] In this invention, the server includes means for registering user profile data, means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data, means for calculating compatibility scores using the user data and feature data saved in the database and generating multiple candidate lists, means for notifying the user of the candidate list, means for providing communication means for sending and receiving messages with candidates selected from the candidate list, and means for displaying the candidate list and related candidate information on a user interface, thereby enabling users to efficiently meet their ideal partner.

[2092] "User profile data" refers to data that includes personal information and attribute information provided by a user.

[2093] The "ideal partner image" is data that represents the characteristics of the user's desired partner, such as personality, appearance, hobbies, and values.

[2094] "Natural language processing" is a technology that allows computers to understand and interpret human language and extract specific information.

[2095] "Feature data" is data that quantifies the ideal partner image extracted through natural language processing.

[2096] A "database" is a system that systematically stores and manages user profile data and characteristic data.

[2097] A "compatibility score" is an evaluation index calculated based on the commonalities and similarities between the user and the candidate.

[2098] A "candidate list" is a list of multiple suitable partner candidates selected based on their compatibility scores.

[2099] "Notification" is the act of informing the user of results or information.

[2100] "Communication means" refers to the technical means by which messages are sent and received between users.

[2101] A "user interface" is a screen or operating means that allows a user to interact with a system.

[2102] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. The system registers the user's profile data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a communication means for sending and receiving messages between the users and the candidates.

[2103] User Registration

[2104] Device:

[2105] When a user accesses the service, a login button and a new registration button are displayed on the home page. When a user clicks the "New Registration" button, a user registration form is displayed.

[2106] User:

[2107] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values, etc.) in the form and click the "Register" button.

[2108] Device:

[2109] The entered user information is sent to the server in JSON format.

[2110] server:

[2111] The received data is temporarily stored, and characteristic keywords are extracted from the "ideal partner image" using a natural language processing engine and converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8, etc.). The user information and extracted characteristic data are then stored in a database.

[2112] Matching process

[2113] server:

[2114] Periodically, a batch job is run to retrieve all user information in the database, and then an algorithm is run to compare each user's ideal partner characteristics with the real data of all other users (e.g., personality, hobbies, values).

[2115] server:

[2116] The commonalities between each user pair are calculated as a score (e.g., if the commonalities "kindness" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on these scores, a list of the most compatible matching candidates is created for each user.

[2117] Notification of matching results

[2118] server:

[2119] Build a list of the most compatible candidates (e.g., top 5 candidates) and store it in a database. Generate matching results for each user and prepare to notify them sequentially.

[2120] Device:

[2121] Registered users are asked to log in and the matching results page is displayed. A list of matching candidates is notified to the user, and basic information (name, age, hobbies, etc.) and photos of each candidate are displayed.

[2122] Messaging Features

[2123] User:

[2124] Click the "Send a message" button for the candidate you like from the list of matching candidates, enter your message in the message input form, and click the "Send" button.

[2125] Device:

[2126] Forwards the sent message to the server.

[2127] server:

[2128] Save the message to a database and notify the receiving user that a new message has arrived (via email or in-app notification).

[2129] Device:

[2130] When the receiving user logs in, it displays new messages. It provides a chat interface for both parties to send and receive messages, and retrieves and displays the message history from the server.

[2131] Specific examples

[2132] Example of user registration

[2133] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[2134] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[2135] Specific example of matching process

[2136] The server executes a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities). A score is calculated based on the commonalities, and the candidate with the highest score is selected.

[2137] Specific examples of notifications

[2138] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[2139] Messaging Examples

[2140] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[2141] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[2142] The device displays the message to Hanako and provides a reply function.

[2143] Example prompts to input to the generative AI model

[2144] "Please describe your ideal partner:"

[2145] "Please extract common items from user data."

[2146] "View the matching results."

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

[2148] User Registration

[2149] Step 1:

[2150] User visits the sign-up form

[2151] Terminal: A user accesses the service's homepage and clicks the "New Registration" button displayed on the homepage. The input is the user's action (click). The output is the user registration form.

[2152] Step 2:

[2153] Enter and submit user information

[2154] User: Enters name, age, gender, email address, and ideal partner profile (personality, appearance, hobbies, values, etc.) into the form and clicks the "Register" button. User information and ideal partner profile are provided as input, and this data is passed to the terminal. As output, this information is sent to the server in JSON format.

[2155] Step 3:

[2156] The server receives and analyzes the data

[2157] Server: Temporarily stores the received user information and uses a natural language processing engine to extract characteristic keywords from the "ideal partner image" and convert them into numerical data. Specific operations include inputting the received user data (e.g., "kind, likes movies") and outputting characteristic data (e.g., "kind" = 0.9, "likes movies" = 0.8).

[2158] Step 4:

[2159] The server stores user information in a database

[2160] Server: Stores user information along with analyzed feature data in a database. User information and feature data are input, and are stored in a database as output.

[2161] Matching process

[2162] Step 1:

[2163] Running a batch job

[2164] Server: Periodically executes a batch job to retrieve all user information in the database. The input is a trigger for the batch job to be executed periodically, and the output is all user data.

[2165] Step 2:

[2166] Retrieving User Data

[2167] Server: Acquires user data to compare the characteristics of each user's ideal partner with the actual data of all other users. The input contains all user data, and the output extracts data for each user.

[2168] Step 3:

[2169] Comparison with the ideal partner

[2170] Server: Runs an algorithm that compares each user's ideal partner image with other users' data and extracts commonalities. The input is the ideal partner image and other users' data, and the output is the extracted commonalities.

[2171] Step 4:

[2172] Compatibility Score Calculation

[2173] Server: Calculates the commonalities of each user pair as a score and calculates the compatibility score. The input is the extracted commonalities data, and the output is the compatibility score (e.g., if the commonalities are "kind" = 0.9 and "likes movies" = 0.8, the total score is 1.7).

[2174] Step 5:

[2175] Generate a list of match candidates

[2176] Server: Creates a list of best-matching candidates for each user based on their compatibility score. The input is the compatibility score and all user data, and the output is a list of best-matching candidates.

[2177] Notification of matching results

[2178] Step 1:

[2179] Save the best candidates list

[2180] Server: Builds a list of best-match candidates and stores it in a database. The input is the generated list of matching candidates, and the output is stored in a database.

[2181] Step 2:

[2182] Preparing to notify users

[2183] Server: Generates matching results for each user and prepares notifications. The input is the stored list of match candidates, and the output is the prepared notifications.

[2184] Step 3:

[2185] Displaying matching results

[2186] Terminal: When a registered user logs in, the matching results page is displayed and the candidate list is notified to the user. The input is each user's login information, and the output is the matching candidate list and related candidate information.

[2187] Messaging Features

[2188] Step 1:

[2189] User sends a message

[2190] User: Clicks the "Send Message" button of the candidate he likes from the list of match candidates, enters a message and sends it. The input contains the user's message, and the output is the message sent.

[2191] Step 2:

[2192] The server receives and stores the message

[2193] Terminal: Forwards the sent message to the server.

[2194] Server: Stores messages in a database and notifies the receiving user that a new message has arrived. Input is the user's message, output is the message stored and notification sent.

[2195] Step 3:

[2196] Notifying the receiving user

[2197] Terminal: Displays new messages when the receiving user logs in. Inputs are login information and saved messages, and output is the new message.

[2198] Step 4:

[2199] Providing a chat interface and displaying message history

[2200] Terminal: Provides a chat interface for both parties to send messages to each other, and retrieves and displays past message history from the server. The input includes the message history of both parties, and the output displays the messages on the chat screen.

[2201] (Application example 1)

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

[2203] Today's consumers have diverse food preferences and lifestyles, making it difficult to efficiently find restaurants and cuisines that suit them. Finding a suitable restaurant often requires a lot of time and effort, resulting in an unsatisfactory selection. Furthermore, there is a lack of systems that allow users with similar food preferences to exchange reviews and opinions with each other. The purpose of this invention is to solve the above problems and provide an AI matching system that allows users to efficiently find their ideal cuisine and restaurant.

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

[2205] In this invention, the server includes means for registering user profile data, means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data, means for calculating compatibility scores using the user data and feature data saved in the database and generating a list of multiple candidates, means for notifying the user of the candidate list, means for providing communication means for sending and receiving messages between the user and candidates selected from the candidate list, means for inputting the user's favorite dishes and characteristics of dishes they want to eat and suggesting optimal restaurants and dishes based on the input, means for saving the characteristic information of the restaurants and dishes in the database and running a matching algorithm together with user information, and means for notifying the user of the list of restaurant and dish suggestions created by the matching algorithm. This allows users to easily find restaurants and dishes that suit their preferences and to have a richer dining experience by exchanging reviews and impressions with other users who share the same preferences.

[2206] "Profile data" refers to data that includes a user's personal information, preferences, attributes, etc.

[2207] "Ideal partner image" refers to data that expresses the characteristics and conditions of the partner that the user desires.

[2208] "Natural language processing" is a technology that uses computers to analyze and understand the natural language used by humans.

[2209] "Feature data" refers to quantified information about a user's wishes and preferences extracted through natural language processing.

[2210] The "compatibility score" is a numerical representation of the commonalities and degree of similarity between the user's wishes and preferences and the characteristics of the candidate.

[2211] A "candidate list" is a list of multiple candidates that match a user, selected based on their compatibility scores.

[2212] "Communication means" refers to the technology and infrastructure used to send and receive messages and data between users.

[2213] "Favorite dishes" refers to the food or dishes that the user particularly likes.

[2214] A "restaurant" is a business that serves food and drinks to customers.

[2215] "Characteristic information" refers to information about restaurants and their cuisine, including their characteristics, reputation, and menu composition.

[2216] A "matching algorithm" is a calculation method or process for selecting the most suitable candidate based on the user's wishes and preferences.

[2217] The following system configuration is used to implement this invention. The main components include registering user profiles, analyzing food and restaurant feature data, calculating compatibility scores, notifying matching results, and sending and receiving messages. This system also uses a natural language processing engine to analyze user input and generate quantified feature data.

[2218] System Configuration

[2219] Hardware: Servers (e.g. AWS EC2), end-user smartphones

[2220] Software: Natural Language Processing (e.g., TensorFlow, spaCy), Database (e.g., MySQL), Backend (e.g., Python, Django), Frontend (e.g., React Native)

[2221] Registering a user profile

[2222] The server receives the data entered by the user in the new registration form and stores it in a database. The user enters their name, age, gender, email address, and ideal cuisine and restaurant characteristics (e.g., likes spicy food, likes Japanese food).

[2223] Analysis of food and restaurant feature data

[2224] The server analyzes the registered profile data using a natural language processing engine (such as TensorFlow or spaCy) to extract characteristic keywords, and stores the analysis results in a database as numerical data.

[2225] Compatibility Score Calculation

[2226] The server periodically uses the user data and feature data stored in the database to run a matching algorithm, comparing each user's features with the restaurant's characteristics, scoring commonalities and generating a list of optimal restaurants.

[2227] Notification of matching results

[2228] The server stores the generated restaurant list (top 5 restaurants) in a database and prepares to notify the user. When a registered user logs in to the app, the device displays the matching results page and provides basic information about the suggested restaurants (restaurant name, address, and cuisine characteristics).

[2229] Message sending and receiving function

[2230] The device allows users to read reviews of restaurants they like from the generated list and send and receive messages with other users. The server stores these messages in a database and notifies other users when a new message arrives.

[2231] Specific examples

[2232] Example of user profile registration

[2233] When a user registers for the app, they enter their name: Taro, age: 30, gender: male, email address: taro@example.com, ideal food and restaurant characteristics: I like spicy food, I like Japanese food.

[2234] Specific examples of feature data analysis

[2235] The server analyzes the input features "I like spicy food" and "I like Japanese food" using a natural language processing engine and stores each as numerical data in a database (e.g., "I like spicy food" = 0.9, "I like Japanese food" = 0.8).

[2236] Prompt Sentence Examples

[2237] "Kind, loves movies, loves Japanese food"

[2238] Using this prompt, the user's preferences can be quantified and the most suitable restaurant can be suggested.

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

[2240] Step 1: User Registration

[2241] The server receives the data entered by the user into the new registration form. Specifically, the server receives the user's name, age, gender, email address, ideal cuisine, and restaurant characteristics in JSON format and stores them in a database. At that time, a natural language processing engine (e.g., TensorFlow, spaCy) is used to extract characteristic keywords and convert them into numerical data (e.g., "spicy" = 0.9, "Japanese food" = 0.8). This converted data is also stored in the database.

[2242] Input: User profile data (name, age, gender, email address, ideal cuisine and restaurant characteristics)

[2243] Output: User information and feature data stored in a database

[2244] Step 2: Analyze feature data

[2245] The server uses a natural language processing engine to analyze the characteristics of the registered profile data. The analyzed characteristics are stored in a database as numerical data. This provides common characteristic information required for calculations.

[2246] Input: User profile data

[2247] Output: quantified feature data

[2248] Step 3: Calculate your compatibility score

[2249] The server periodically executes a batch job to retrieve user data and feature data stored in the database. The feature data of each user is compared with the characteristic information of all restaurants to calculate a compatibility score. Based on the score calculation algorithm, the commonalities are quantified and a list of the most suitable restaurants is generated.

[2250] Input: Customer data and restaurant characteristics information

[2251] Output: A list of the best restaurants for each user

[2252] Step 4: Notification of match results

[2253] The server stores the generated restaurant list (e.g., the top five restaurants) in a database. When the user logs in to the app, the device displays a matching results page, which shows basic information about the suggested restaurants (such as restaurant name, address, and cuisine characteristics).

[2254] Input: A list of restaurants that are best suited for each user

[2255] Output: Matching results notified to the user

[2256] Step 5: Sending and receiving messages

[2257] The terminal provides a function to read reviews of restaurants that the user likes from the restaurant list that the user created. The user can send and receive messages with other users. The server stores the sent messages in a database and notifies other users when a new message arrives.

[2258] Input: Message from user

[2259] Output: Messages sent and received, messages stored in the database

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

[2261] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. This system registers the user's profile data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a means of communication for sending and receiving messages between the candidates, and by combining it with an emotion engine, it can recognize the user's emotions and optimize the matching process.

[2262] User Registration

[2263] Device:

[2264] When a user accesses the service and opens the homepage, a login button and a new registration button are displayed. When the user clicks the "New Registration" button, a user registration form is displayed.

[2265] User:

[2266] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values, etc.) in the form and click the "Register" button.

[2267] Device:

[2268] The entered user information is converted to JSON format and sent to the server.

[2269] server:

[2270] The received data is temporarily stored. The "ideal partner image" is analyzed using a natural language processing engine to extract characteristic keywords. The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8). The user information and characteristic data are then stored in a database.

[2271] Matching process and emotion engine usage

[2272] server:

[2273] Periodically, a batch job is run to retrieve all user information in the database, and then an algorithm is run to compare each user's ideal partner characteristics with the actual data of all other users.

[2274] The commonalities between each user pair are calculated as a score (e.g., if the commonalities are "kind" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on the calculated scores, a list of compatible candidates is generated for each user.

[2275] Furthermore, an emotion engine is used to recognize emotions from the content of users' messages. The recognized emotion data is then taken into consideration during matching to select more suitable candidates.

[2276] Notification of matching results

[2277] server:

[2278] Build a list of the most compatible candidates (e.g., top 5). Prepare and save the matching result data for each user.

[2279] Device:

[2280] When a user logs in, a matching results page will be displayed. A list of matching candidates will be notified to the user, and basic information (name, age, hobbies, etc.) and photos of each candidate will be displayed.

[2281] Use of messaging features and emotion engines

[2282] User:

[2283] Click the "Send Message" button for the candidate you like from the list of matching candidates. Enter your message in the message input form and click the "Send" button.

[2284] Device:

[2285] Forwards the sent message to the server.

[2286] server:

[2287] Save the message to a database and notify the receiving user (via email or in-app notification) that a new message has arrived.

[2288] It also uses an emotion engine to analyze the emotions in sent messages and provides suggestions to optimize the next communication based on the recognized emotion data.

[2289] Device:

[2290] It displays new messages when the receiving user logs in. It provides a chat interface for both parties to send messages to each other, and retrieves and displays message history from the server.

[2291] Specific examples

[2292] Example of user registration

[2293] When the device is accessed for the first time, it displays a user registration form, and the user enters "Name: Taro, Age: 30, Gender: Male, Email address: taro@example.com, Ideal partner: A kind woman who likes movies." The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[2294] Specific example of matching process

[2295] The server runs a batch job, retrieves all user data, and calculates the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities). A score is calculated based on the commonalities, and an emotion engine is used to consider emotional data to select the candidate with the highest score.

[2296] Specific examples of notifications

[2297] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[2298] Messaging Examples

[2299] The user selects Hanako from the list of candidates and enters the message "Hello, this is Taro. I heard you like movies, so I'm messaging you!" The device forwards the message to the server, which notifies Hanako of the new message. The emotion engine recognizes the emotion of the message and stores that data. From the next time onwards, suggestions are provided that take the emotion data into account. The device displays the message to Hanako and provides a reply function.

[2300] The processing flow will be explained below.

[2301] Program processing steps

[2302] Step 1: User Registration

[2303] 1. Device:

[2304] Displays the homepage and provides login and registration buttons.

[2305] When the user clicks the "New Registration" button, a user registration form is displayed.

[2306] 2. User:

[2307] Enter your name, age, gender, email address, and ideal partner (personality, hobbies, values, etc.) in the form.

[2308] Click the "Register" button.

[2309] 3. Terminal:

[2310] The entered user information is converted to JSON format and sent to the server.

[2311] 4. Server:

[2312] Temporarily saves received data.

[2313] The natural language processing engine analyzes the "ideal partner image" and extracts characteristic keywords.

[2314] The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8).

[2315] Store user information and feature data in a database.

[2316] Step 2: Matching process and using the emotion engine

[2317] 1. Server:

[2318] Periodically run a batch job to retrieve all user information in the database.

[2319] It runs an algorithm that compares the characteristics of each user's ideal partner with the real data of all other users.

[2320] 2. Server:

[2321] The commonality between each user pair is calculated as a score (e.g., if the commonality "kindness" = 0.9 and the commonality "likes movies" = 0.8, the total score = 1.7).

[2322] Based on the calculated score, a list of compatible candidates is generated for each user.

[2323] Furthermore, an emotion engine is used to recognize emotions from the content of the user's message.

[2324] The recognized emotion data is used to take into consideration during matching to select more suitable candidates.

[2325] Step 3: Notification of match results

[2326] 1. Server:

[2327] Build a list of the most compatible candidates (e.g., top 5).

[2328] Prepare and store matching result data for each user.

[2329] 2. Terminal:

[2330] When a user logs in, a matching results page will be displayed.

[2331] The user is notified of a list of matching candidates, and basic information (name, age, hobbies, etc.) and a photo of each candidate are displayed.

[2332] Step 4: Use messaging and emotion engines

[2333] 1. User:

[2334] Click the "Send Message" button for the candidate you like from the list of matching candidates.

[2335] Enter your message in the message input form and click the "Send" button.

[2336] 2. Terminal:

[2337] Forwards the sent message to the server.

[2338] 3. Server:

[2339] Save the message in the database.

[2340] Notify the receiving user that a new message has arrived (via email or in-app notification).

[2341] It also uses an emotion engine to analyze the emotions in sent messages and provides suggestions to optimize the next communication based on the recognized emotion data.

[2342] 4. Terminal:

[2343] Displays new messages when the receiving user logs in.

[2344] It provides a chat interface for both parties to send messages to each other.

[2345] Retrieve and display message history from the server.

[2346] Specific examples

[2347] Step 1 example

[2348] When the device is accessed for the first time, a user registration form is displayed, and the user enters the following information: name: Taro, age: 30, gender: male, email address: taro@example.com, ideal partner: a kind woman who likes movies.

[2349] The device sends the input information to the server, which then converts "kind" and "likes movies" into numerical values ​​and stores them in a database.

[2350] Step 2: Example

[2351] The server runs a batch job to retrieve all user data and calculate the commonalities between each user and their ideal partner (e.g., Taro and Hanako have two commonalities).

[2352] A score is calculated based on commonalities, and then an emotion engine is used to take emotional data into account to select the candidate with the highest score.

[2353] Step 3 example

[2354] The server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobby: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[2355] Step 4: Example

[2356] The user selects Hanako from the list of candidates and enters the message "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[2357] The terminal forwards the message to the server, which then notifies Hanako of the new message.

[2358] It uses an emotion engine to recognize the emotion of the message and stores that data as well.

[2359] The system will provide suggestions that take emotional data into account in future messaging.

[2360] The device displays the message to Hanako and provides a reply function.

[2361] Example 2

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

[2363] Conventional matching systems have the problem of being unable to accurately analyze a user's ideal partner and present appropriate candidates. Furthermore, they lack the means to support communication between candidates and promote smooth relationship building, in addition to generating and notifying candidate lists. Furthermore, because they are unable to match users based on their emotions, potential compatibility may not be fully realized.

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

[2365] In this invention, the server includes means for registering user attribute data, means for analyzing the ideal partner image provided by the user using natural language processing and saving it as feature data, means for calculating compatibility scores and generating a list of multiple candidates using the user data and feature data saved in the database, means for notifying the user of the candidate list, means for providing communication means for sending and receiving information to and from candidates selected from the candidate list, and means for analyzing emotional data in the sent and received information using an emotion analysis engine and optimizing the matching process. This makes it possible to accurately analyze the user's ideal partner image, present the most suitable candidates, and optimize communication taking the emotional data into consideration.

[2366] "User" refers to an individual who uses this system, registers profile data, and receives matching services.

[2367] "Attribute data" refers to information about users provided by users, such as their name, age, gender, email address, and ideal partner image.

[2368] "Natural language processing" refers to the technology of analyzing text data provided by users and extracting meaning and characteristics from it.

[2369] "Feature data" refers to data that quantifies information about an ideal partner extracted through natural language processing.

[2370] "Database" refers to a system for storing user data and characteristic data and for searching and updating them as needed.

[2371] "Compatibility score" refers to the score calculated by comparing a user's ideal partner with the data of other users.

[2372] "Candidate List" refers to a list of potential partners who are compatible with the user, generated based on the compatibility score.

[2373] "Communication means" refers to means for sending and receiving information such as messages between users.

[2374] "Sentiment analysis engine" refers to an analytical device or software that analyzes the content of a message and recognizes the emotions contained therein.

[2375] "Optimization" refers to a method or process for maximizing the efficiency and effectiveness of the matching process and communication, taking into account emotional data, etc.

[2376] This invention relates to an AI matching system that enables users to efficiently find their ideal partner. This system registers the user's attribute data, analyzes and quantifies the ideal partner image using natural language processing, calculates a compatibility score using information stored in a database, and generates and notifies the user of a list of the most compatible candidates. It also provides a means of communication for sending and receiving information between the users and the candidates. By combining this with an emotion analysis engine, the system can recognize the user's emotions and optimize the matching process.

[2377] User Registration

[2378] Device:

[2379] When a user accesses the service and opens the homepage, a login button and a new registration button are displayed. When the user clicks the "New Registration" button, a user registration form is displayed.

[2380] User:

[2381] Enter your name, age, gender, email address, and ideal partner (personality, appearance, hobbies, values) in the form and click the "Register" button. As a concrete example, a user enters "Name: Taro, Age: 30, Gender: Male, Email address: taro@example.com, Ideal partner: Kind woman who likes movies."

[2382] Device:

[2383] The entered user information is converted to JSON format and sent to the server.

[2384] server:

[2385] The received data is temporarily stored. The "ideal partner" is analyzed using a natural language processing engine (e.g., SpaCy or BERT) to extract characteristic keywords. The extracted characteristic keywords are converted into numerical data (e.g., "kind" = 0.9, "likes movies" = 0.8). The user information and characteristic data are then stored in a database.

[2386] Matching process and emotion engine usage

[2387] server:

[2388] Periodically, a batch job is run to retrieve all user information in the database. An algorithm is run to compare the characteristics of each user's ideal partner with the actual data of all other users. The commonalities between each user pair are calculated as a score (e.g., if the commonalities are "kind" = 0.9 and "like movies" = 0.8, the total score is 1.7). Based on the calculated scores, a list of compatible candidates is generated for each user.

[2389] Furthermore, a sentiment analysis engine (e.g., Microsoft Azure's Text Analytics API) is used to recognize emotions from the content of users' messages. The recognized emotional data is then taken into consideration during matching to select more suitable candidates.

[2390] Notification of matching results

[2391] server:

[2392] Build a list of the most compatible candidates (e.g., top 5). Prepare and save the matching result data for each user.

[2393] Device:

[2394] When a user logs in, a matching results page is displayed. The user is notified of a list of matching candidates, and basic information (name, age, hobbies, etc.) and photos of each candidate are displayed. As a specific example, the server sends Taro information about candidates who are compatible with him (e.g., Hanako, 28 years old, female, hobbies: movies), and the terminal displays a list of five candidates and their profiles to Taro.

[2395] Use of messaging features and emotion engines

[2396] User:

[2397] Click the "Send Message" button for the candidate you like from the list of matching candidates. Enter a message in the message input form and click the "Send" button. For example, a user might enter "Hello, I'm Taro. I heard you like movies, so I'm messaging you!"

[2398] Device:

[2399] Forwards the sent message to the server.

[2400] server:

[2401] It stores messages in a database, notifies the receiving user of new messages (via email or in-app notification), and uses a sentiment analysis engine to analyze the sentiment of the message and provide suggestions to optimize the next communication based on the recognized sentiment data.

[2402] Device:

[2403] It displays new messages when the receiving user logs in. It provides a chat interface for both parties to send messages to each other, and retrieves and displays message history from the server.

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

[2405] Step 1:

[2406] The user fills out the registration form

[2407] explanation:

[2408] A user accesses the system's homepage and clicks the "New Registration" button. A registration form is then displayed. The user enters their name, age, gender, email address, and ideal partner profile (personality, appearance, hobbies, and values).

[2409] input:

[2410] User inputs name, age, gender, email address, and ideal partner image

[2411] output:

[2412] User-entered data

[2413] Specific behavior:

[2414] A user enters "Name: Taro, Age: 30, Gender: Male, Email address: taro@example.com, Ideal partner: Kind woman who likes movies."

[2415] Step 2:

[2416] The device sends user input to the server

[2417] explanation:

[2418] The device converts the data entered in the registration form into JSON format and sends the converted data to the server using an HTTP POST request.

[2419] input:

[2420] User-entered data

[2421] output:

[2422] JSON format data

[2423] Specific behavior:

[2424] The device will generate JSON data like this:

[2425] json

[2426] {

[2427] "Name": "Taro",

[2428] "Age": 30,

[2429] "Gender": "Male",

[2430] "Email address": "taro@example.com",

[2431] "Ideal partner": "A kind woman who loves movies"

[2432] }

[2433] POST the converted data to https: / / example.com / api / register.

[2434] Step 3:

[2435] The server processes the received data and stores it in a database

[2436] explanation:

[2437] The server parses the received JSON data. It uses a natural language processing engine (e.g., SpaCy or BERT) to analyze the "ideal partner" field and extracts characteristic keywords. It converts these characteristics into numerical values, e.g., "kind" = 0.9, "likes movies" = 0.8. It then stores these values ​​in a database along with the overall user data.

[2438] input:

[2439] User data in JSON format

[2440] output:

[2441] User information and feature data stored in a database

[2442] Specific behavior:

[2443] The server does the following:

[2444] 1. Parse the JSON data.

[2445] 2. Use a natural language processing engine to extract characteristic keywords such as "kind" and "likes movies."

[2446] 3. Quantify the characteristic keywords.

[2447] 4. Store user information and feature data in a database.

[2448] Step 4:

[2449] The server runs a batch job to retrieve the user data

[2450] explanation:

[2451] A scheduled batch job runs at regular intervals to retrieve all user data from the database.

[2452] input:

[2453] All user data stored in the database

[2454] output:

[2455] All user data obtained

[2456] Specific behavior:

[2457] The server periodically runs a batch job to retrieve all user information from the database.

[2458] Step 5:

[2459] The server calculates compatibility scores and generates a candidate list.

[2460] explanation:

[2461] Based on the acquired user data, an algorithm is run to compare each user's ideal partner image with the data of all other users. The more commonalities there are, the higher the compatibility score is calculated, and a list of compatible candidates is generated for each user.

[2462] input:

[2463] All user data

[2464] output:

[2465] Candidate list for each user

[2466] Specific behavior:

[2467] The server does the following:

[2468] 1. Compare each user's ideal partner profile with all other user data.

[2469] 2. The score is calculated so that the more commonalities there are, the higher the score.

[2470] 3. Generate a list of compatible candidates for each user.

[2471] Step 6:

[2472] The server uses a sentiment analysis engine to optimize matching.

[2473] explanation:

[2474] The content of the messages is analyzed to extract the emotional data contained within them. A sentiment analysis engine is used to recognize the sentiment of the messages, and this data is fed back into the matching process to select more suitable candidates.

[2475] input:

[2476] Message content

[2477] output:

[2478] Emotional Data

[2479] Specific behavior:

[2480] The server does the following:

[2481] 1. Input the message into the sentiment analysis engine.

[2482] 2. Obtain emotional data using a sentiment analysis engine.

[2483] 3. Use sentiment data to optimize the matching process.

[2484] Step 7:

[2485] The server builds a list of candidates and stores it in a database

[2486] explanation:

[2487] A list of the most compatible candidates is constructed and the matching result data for each user is stored in a database.

[2488] input:

[2489] List of candidates with high compatibility scores

[2490] output:

[2491] Matching result data stored in the database

[2492] Specific behavior:

[2493] The server does the following:

[2494] 1. Build a shortlist based on compatibility scores.

[2495] 2. Save the matching result data in the database.

[2496] Step 8:

[2497] The device notifies the user of the matching results

[2498] explanation:

[2499] When a user logs in, the matching results are retrieved from the server and displayed on the homepage. A list of candidates is displayed, along with basic information and photos of each candidate.

[2500] input:

[2501] Matching result data stored in the database

[2502] output:

[2503] A list of matching candidates displayed on the screen

[2504] Specific behavior:

[2505] The device will:

[2506] 1. The user logs in.

[2507] 2. Get the matching results from the server.

[2508] 3. Display a list of matching candidates, along with basic information and photos of each candidate.

[2509] Step 9:

[2510] The user types and sends a message

[2511] explanation:

[2512] Select a specific candidate from the list of matching candidates, enter a message, and click the "Send" button.

[2513] input:

[2514] A message entered by the user

[2515] output:

[2516] Message data to be sent

[2517] Specific behavior:

[2518] The user types, "Hi, I'm Taro. I heard you like movies, so I'm messaging you!"

[2519] Step 10:

[2520] The device forwards the message to the server

[2521] explanation:

[2522] The input message is converted back to JSON format for transmission to the server and sent using an HTTP request.

[2523] input:

[2524] A message entered by the user

[2525] output:

[2526] Message data in JSON format

[2527] Specific behavior:

[2528] The device generates the following JSON data and sends it to the server:

[2529] json

[2530] {

[2531] "Sender": "Taro",

[2532] "Recipient": "Hanako",

[2533] "Message": "Hello, I'm Taro. I heard you like movies, so I messaged you!"

[2534] }

[2535] Step 11:

[2536] The server notifies the receiving user and parses the message.

[2537] explanation:

[2538] The message is saved in a database, the receiving user is notified that a new message has arrived, and the message content is analyzed using an emotion analysis engine, and the emotional data is saved for use in the next communication.

[2539] input:

[2540] Message data sent

[2541] output:

[2542] Notifications sent to the receiving user and stored emotion data

[2543] Specific behavior:

[2544] The server does the following:

[2545] 1. Save the message in the database.

[2546] 2. Send a notification to the recipient user.

[2547] 3. The sentiment analysis engine analyzes the sentiment of the message and stores the data.

[2548] Step 12:

[2549] The device displays the new message to the receiving user.

[2550] explanation:

[2551] When the receiving user logs in, it displays new messages and provides reply functionality.

[2552] input:

[2553] New messages notified

[2554] output:

[2555] New on-screen messaging and reply features

[2556] Specific behavior:

[2557] The device will:

[2558] 1. The receiving user logs in.

[2559] 2. View new messages.

[2560] 3. Provide a reply function.

[2561] (Application example 2)

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

[2563] Conventional matching systems sometimes had difficulty proposing suitable candidates and products based on users' preferences and tendencies. Additionally, they lacked a mechanism to understand the emotions expressed in messages sent by users through the system and provide optimal support accordingly, which resulted in a lack of improvement in the user experience.

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

[2565] In this invention, the server includes means for registering user identification information, means for analyzing the ideal target image provided by the user using natural language processing and saving it as feature data, means for calculating an evaluation score using the user data and feature data saved in the database and generating multiple recommendation lists, means for notifying the user of the recommendation lists, means for providing a communication means for sending and receiving messages to targets selected from the recommendation lists, and means for analyzing the emotions in the messages and providing optimal support, thereby making it possible to suggest suitable candidates and products to the user and provide optimal support according to their emotions.

[2566] "User" refers to an individual who uses the system to register profile data and receive matching and product recommendations.

[2567] "Identification information" is data used to identify an individual user, and often includes basic information such as name and email address.

[2568] "Natural language processing" is a set of techniques that allow computers to understand human language, and involves analyzing text data and extracting features.

[2569] "Feature data" is data that quantifies or categorizes the user's ideal target image, and is used as a basis for matching and re...

Claims

1. means for registering user profile data; A means for analyzing the ideal partner image provided by the user using natural language processing and storing the same as characteristic data; A means for calculating a compatibility score using user data and characteristic data stored in a database and generating a plurality of candidate lists; a means for notifying a user of the candidate list; and means for providing a communication means for sending and receiving messages to and from candidates selected from the candidate list.

2. Quantifying feature data using natural language processing The system of claim 1 .

3. When calculating the compatibility score, the score is calculated based on the number of common points between the user and the candidate. The system of claim 1 .

Images