System

Abstract

A system is provided.SOLUTION: A system comprising: means for extracting keywords from an election bulletin; means for vectorizing the extracted keywords; means for storing keyword vectors associated with each candidate in a database; means for randomly presenting the stored keywords; means for vectorizing keywords selected by a user; means for calculating a similarity between a user vector and a candidate vector; and means for displaying candidates based on the similarity.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] In elections, voters face the challenge of being overwhelmed with information and finding it difficult to understand when deciding who to vote for. Young people in particular tend to have difficulty understanding policy content, and their voting behavior tends to depend on their impressions of politics and their feelings toward a particular political party. This situation hinders political participation and threatens to weaken the functioning of democracy. Therefore, there is a need for a system that encourages appropriate voting behavior by allowing voters to easily find candidates whose views align with their own. [Means for solving the problem]

[0005] To address this issue, the present invention provides a system that extracts keywords from election bulletins, vectorizes them, and associates them with each candidate. This system includes a means for storing keyword vectors for each candidate in a database and randomly presenting keywords for all candidates. First, a user selects keywords of interest, and the selected keywords are vectorized. Next, the similarity between the user vector and the stored candidate vectors is calculated, and based on the result, the candidate closest to the user's beliefs is displayed. This similarity calculation preferably uses keyword vectorization using TF-IDF and cosine similarity. Such a system allows voters to easily find the candidate closest to their beliefs, increasing their motivation to vote and facilitating their understanding of election information.

[0006] An "election bulletin" is a document prepared and publicly distributed by a candidate to communicate his or her policies and promises to voters.

[0007] "Keywords" are important words and phrases extracted from election bulletins that represent the characteristics of each candidate's policies and pledges.

[0008] A "vector" is a set of data with numerical values ​​and components, and is a numerical representation of keywords in election bulletins.

[0009] "Users" refer to voters who use the system to select candidates based on their own interests.

[0010] A "database" is a collection of information in which candidate keyword vectors are stored and managed.

[0011] "Random presentation" means that keywords are randomly selected and presented to the user without following any particular order or pattern.

[0012] "Vectorization" is the process of converting text data (keywords) into numbers and representing them in a multidimensional space.

[0013] "Similarity" is a numerical measurement of the common elements between a user vector and a candidate vector, and is an index that indicates how similar the two vectors are.

[0014] "TF-IDF" stands for Term Frequency-Inverse Document Frequency, and is a numerical index used to evaluate the importance of each word in a text.

[0015] "Cosine similarity" is a method of measuring similarity using the cosine value of the angle between two vectors, and the closer the value is to 1, the more similar the vectors are. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0024] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0037] As an embodiment of the present invention, a system is provided that extracts keywords from election bulletins and allows voters to select candidates based on their own interests. This system is configured as follows.

[0038] 1. Collection of election bulletins

[0039] The server collects the election bulletins of each candidate and stores their campaign promises and policy details in text format. For example, Candidate A's campaign promises include "improving education and increasing housing support."

[0040] 2. Keyword extraction and vectorization

[0041] The server preprocesses the collected text data, converting it to lowercase and removing punctuation as necessary. It then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and convert them into numerical vectors. This allows the importance of each keyword to be expressed as a number.

[0042] 3. Saving Vector Data

[0043] The server stores the generated keyword vectors in a database, which allows the policies and pledges of each candidate to be managed as numerical data.

[0044] 4. Keyword Randomization

[0045] The server compiles all candidate keywords into a single list and randomly shuffles it. Randomization allows users to choose keywords without any fixed bias.

[0046] 5. User-selected keywords

[0047] The user uses the terminal to select keywords that interest them from the presented keyword list, for example, "education" and "economy."

[0048] 6. Vectorize the selected keywords

[0049] The server runs a process to vectorize the keywords selected by the user, using the simple method of setting a 1 in positions where the selected keyword occurs and a 0 in other positions.

[0050] 7. Similarity calculation

[0051] The server calculates the similarity between the user vector and each candidate's keyword vector. It uses cosine similarity to measure the similarity between each vector as a number. This similarity calculation evaluates which candidate is closest to the user's chosen keywords.

[0052] 8. Display of Candidates

[0053] The server sorts the candidates based on the calculated similarity. Finally, the list is displayed to the user in order of the candidates who are closest to the user's own beliefs. For example, if the user has a strong interest in "education" and "economy," candidates who match these interests will be displayed first.

[0054] Specific examples

[0055] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[0056] Through the terminal, the user selects "education" and "economy" from a random list of keywords presented to them.

[0057] The server creates a user vector based on these keywords.

[0058] The server calculates the cosine similarity between the user vector and the candidate's keyword vector to find the candidate that is closest to the user.

[0059] The server displays candidates in descending order of similarity, and for example, if candidate A has the highest similarity, candidate A will be displayed at the top.

[0060] The system allows users to easily find the most suitable candidates based on their interests, facilitating voting decisions, allowing voters to cast their votes based on policy content, promoting a transparent and fair election process.

[0061] The processing flow will be explained below.

[0062] Step 1:

[0063] The server collects election bulletins and stores the contents of each candidate's policies and pledges in text format. For example, the pledges of "Candidate A" include "improving education and increasing housing support."

[0064] Step 2:

[0065] The server formats and preprocesses the collected text data, specifically lowercasing the text and removing punctuation and special characters.

[0066] Step 3:

[0067] The server applies TF-IDF (Term Frequency-Inverse Document Frequency) to the preprocessed text data to extract keywords from each election bulletin. The extracted keywords are expressed as numerical vectors.

[0068] Step 4:

[0069] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each candidate.

[0070] Step 5:

[0071] The server compiles all candidate keywords into a single list and randomly shuffles this list, allowing voters to choose unbiased from the presented keyword list.

[0072] Step 6:

[0073] The terminal presents the shuffled keyword list to the user, who then selects some keywords from the list based on his or her own interests.

[0074] Step 7:

[0075] The server creates a user vector based on the keywords selected by the user. For example, if the selected keyword is in a specific position on the list, it sets that position to 1, and all other positions to 0.

[0076] Step 8:

[0077] The server calculates the cosine similarity between the created user vector and each candidate keyword vector stored in the database. Using the cosine similarity, the angle between the user vector and the candidate vector is measured and the similarity is evaluated as a numerical value.

[0078] Step 9:

[0079] The server sorts the candidates based on the calculated cosine similarity, allowing it to list the candidates most suitable for the user.

[0080] Step 10:

[0081] The device will display candidates to the user in order of similarity. For example, if the user is interested in "education" and "economy," the candidate who best matches those interests will be displayed at the top. The user can then decide who to vote for based on this list.

[0082] Example 1

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

[0084] Conventional election information systems make it difficult for voters to obtain detailed information about candidates' pledges and policies in a centralized manner and select the appropriate candidate based on their own interests. Furthermore, there was a lack of improved accuracy in keyword extraction and vectorization, as well as automated data collection methods, which could potentially compromise the transparency and fairness of election information. There was a need to provide a system that would solve these issues and enable voters to select candidates efficiently and fairly.

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

[0086] In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for storing keyword vectors associated with each candidate in a database, means for randomly presenting the stored keywords, means for vectorizing keywords selected by a user, means for calculating the similarity between a user vector and a candidate vector, means for displaying candidates based on the similarity, means for automating the collection of election bulletin data, means for randomly displaying keywords selected by a user, and means for preprocessing keyword data by lowercasing and removing punctuation. This enables voters to efficiently select candidates based on their interests, improving the transparency and fairness of election information.

[0087] An "election bulletin" is an official document published by each candidate in an election to communicate their campaign promises and policies to voters.

[0088] "Keyword extraction methods" are techniques and algorithms used to extract important words and phrases from election bulletins.

[0089] "Vectorization" is the process of converting keywords or text data into numerical vectors, making them computable.

[0090] "Means for storing in a database" refers to a technology or system for efficiently storing the generated keyword vectors so that they can be easily searched and accessed later.

[0091] A "random presentation method" is a technique or algorithm for randomly rearranging keywords and presenting them to the user without relying on a specific order.

[0092] The "means for vectorizing user-selected keywords" is a process for converting user-selected keywords into numerical vectors, making them comparable with other data.

[0093] The "means for calculating similarity" refers to a technique or algorithm for numerically indicating the similarity between a user vector and a candidate vector and for making an evaluation based on that numerical value.

[0094] The "means for displaying candidates" refers to a technology or system for sorting candidates based on the calculated similarity and visually presenting them to the user.

[0095] "Means for automating the collection of election bulletin data" refers to web scraping and data mining technologies for efficiently and automatically collecting election bulletin data.

[0096] "Means for lowercasing and removing punctuation marks as preprocessing of keyword data" refers to techniques and processes for lowercasing and removing unnecessary punctuation marks to make text data easier to analyze.

[0097] This invention provides a system that extracts keywords from election bulletins and allows voters to select candidates based on their interests. This system consists of three main components: a server, a terminal, and a user.

[0098] The server first collects election bulletin data. Specifically, it uses web scraping technology (for example, Python's BeautifulSoup library) to obtain election bulletins from the official website of the Election Commission and each candidate's website, and saves them in text format. The saved text data is then preprocessed using natural language processing libraries such as NLTK and spaCy. Preprocessing includes lowercasing and removing punctuation.

[0099] Next, the server extracts important keywords from the preprocessed text data using TF-IDF and converts them into numerical vectors using the scikit-learn library. This vector data is then stored in a database (e.g., MySQL or PostgreSQL).

[0100] The server then combines all candidate keyword lists into a single list and randomly shuffles it using Python's random library, ready to be presented to the user.

[0101] Users select keywords that interest them from a random keyword list presented to them using their device (PC or smartphone). The selected keywords are then vectorized by the server using one-hot encoding technology.

[0102] Next, the server calculates the cosine similarity between the keyword vector selected by the user and the keyword vector of each candidate, again using the scikit-learn library. Based on the calculated similarity, the candidates are sorted in order of their proximity to the user's interests.

[0103] Finally, the server displays the results of the similarity calculation to the user via their terminal, and the user can select the most suitable candidate based on the presented information.

[0104] As a specific example, consider the case where a user is interested in "education" and "economy."

[0105] 1. The server collects and preprocesses election bulletin data.

[0106] 2. The server extracts important keywords and vectorizes them. In this case, for example, "education" and "economy" are extracted.

[0107] 3. The server randomly shuffles all candidate keywords and presents them to the user.

[0108] 4. The user selects "education" and "economy" from the presented keyword list.

[0109] 5. The server creates a user vector based on the user's selection and calculates the similarity with each candidate's vector using cosine similarity.

[0110] 6. The server sorts the candidates based on similarity and displays them to the user via their device. The user then makes a voting decision based on the displayed list of candidates.

[0111] This system allows users to select candidates efficiently and fairly.

[0112] Prompt example

[0113] "Please extract policy keywords related to education and the economy from the latest election bulletins and recommend candidates based on those."

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

[0115] System program processing flow

[0116] Step 1: Collect election information

[0117] The server periodically collects election bulletin data from the official website of the Election Commission and each candidate's website. Specifically, it uses Python's BeautifulSoup library to scrape web pages and obtains candidates' campaign promises and policy details in text format.

[0118] Input: URL of the web page where the election bulletin is published

[0119] Output: Candidate pledge data in text format

[0120] Specific operation: HTML parsing and text extraction using BeautifulSoup

[0121] Step 2: Keyword extraction and preprocessing

[0122] The server preprocesses the collected text data by using Python's NLTK and spaCy to lowercase the text and remove punctuation and special characters, and then uses the TF-IDF method to extract important keywords.

[0123] Input: Candidate pledge data in text format

[0124] Output: Preprocessed text data and important keywords

[0125] Specific operation: Preprocessing using NLTK and spaCy (lowercasing, punctuation removal), keyword extraction using TF-IDF

[0126] Step 3: Vectorize keywords

[0127] The server vectorizes the keywords extracted from the preprocessed text data using the scikit-learn library. Based on the TF-IDF score, the importance of each keyword is expressed as a numerical vector.

[0128] Input: Preprocessed text data and important keywords

[0129] Output: TF-IDF based keyword vectors

[0130] Specific operation: TF-IDF score calculation and vectorization

[0131] Step 4: Save the vector data

[0132] The server stores the generated keyword vectors in a database (e.g., MySQL or PostgreSQL). A keyword vector is saved for each candidate, allowing for easy searching and access later.

[0133] Input: TF-IDF based keyword vectors

[0134] Output: Keyword vectors stored in a database

[0135] Specific operation: Write operation to database

[0136] Step 5: Randomize Keywords

[0137] The server compiles all candidate keyword lists into a single list and randomly shuffles them using Python's random library, which is then presented to the user.

[0138] Input: Keyword vectors stored in a database

[0139] Output: Randomly shuffled keyword list

[0140] Specific operation: Shuffling using the Random library

[0141] Step 6: User-selected keywords

[0142] Users use their devices (PCs or smartphones) to select keywords that interest them from a randomly arranged keyword list by clicking or tapping on the screen.

[0143] Input: Randomly shuffled keyword list

[0144] Output: User selected keywords

[0145] Specific action: Keyword selection through the user interface

[0146] Step 7: Vectorize your chosen keywords

[0147] The server vectorizes the keywords selected by the user using one-hot encoding, which sets 1 to the vector position corresponding to the selected keyword and 0 to the other positions.

[0148] Input: User-selected keywords

[0149] Output: User vectors by one-hot encoding

[0150] Specific operation: Vectorization of user keywords (one-hot encoding)

[0151] Step 8: Similarity calculation

[0152] The server calculates the similarity between the user vector and each candidate's keyword vector, using the cosine_similarity function from the scikit-learn library.

[0153] Input: User vectors obtained by one-hot encoding, candidate keyword vectors stored in the database

[0154] Output: Cosine similarity with each candidate

[0155] Specific operation: Calculating cosine similarity (cosine_similarity in scikit-learn)

[0156] Step 9: View candidates

[0157] The server sorts the candidates based on the calculated similarity and displays them on the user's device in order of the most similar. The user then makes a voting decision based on the information presented.

[0158] Input: Cosine similarity with each candidate

[0159] Output: A list of candidates based on similarity

[0160] Specific behavior: Displaying a list of candidates through a user interface

[0161] Prompt example

[0162] "Please extract policy keywords related to education and the economy from the latest election bulletins and recommend candidates based on those."

[0163] (Application example 1)

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

[0165] Current food delivery systems provide a wide range of menus and restaurant information, but it is difficult for users to select the most suitable dishes and dining establishments based on their interests. In addition, when users search for menus or restaurants based on specific keywords, bias is likely to occur, making it difficult to obtain truly personalized suggestions.

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

[0167] In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for storing keyword vectors associated with each candidate in a database, means for randomly presenting the stored keywords, means for vectorizing keywords selected by the user, means for calculating the similarity between the user vector and the candidate vector, means for displaying candidates based on the similarity, means for collecting information on food menus and dining establishments, extracting and vectorizing keywords from menu descriptions, and means for recommending food menus and dining establishments based on the keywords selected by the user, thereby enabling users to receive personalized meal suggestions based on their interests.

[0168] An "election bulletin" is an official document in which a candidate outlines his or her policies and positions during the election campaign.

[0169] "Keywords" are words or phrases that summarize and highlight a particular context or piece of information.

[0170] "Vectorization" is the process of converting non-numeric information, such as text data, into numerical vectors, making them analyzable.

[0171] A "database" is a system for efficiently storing, managing, and searching structured data.

[0172] "Random presentation" means presenting information randomly, without any particular order or regularity.

[0173] "Similarity" is a measure of the relative closeness or relatedness between two objects.

[0174] A "food menu" is a list of the foods and drinks served at a food establishment.

[0175] "Food and beverage establishment" means a facility for serving food and beverages.

[0176] "Extraction" is the process of selecting specific information or elements from the original data set.

[0177] "TF-IDF" stands for Term Frequency-Inverse Document Frequency and is a statistical method for measuring the importance of words in a document.

[0178] "Cosine similarity" is a method for measuring the similarity between two vectors using the angle between them.

[0179] The present invention is a food delivery system that allows users to find the most suitable food menu and dining establishment based on their interests. A specific example of the system is described below.

[0180] 1. Data Collection:

[0181] The server collects information about food menus and restaurants, including menu names, descriptions, prices, and types of food. This data is saved as a data file in CSV format or similar.

[0182] 2. Keyword extraction and vectorization:

[0183] The server preprocesses the collected text data, converting it to lowercase and removing punctuation. It then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and convert them into numerical vectors. This process uses the Python libraries scikit-learn and Pandas.

[0184] 3. Random keyword suggestions:

[0185] The server creates a list of extracted keywords, randomly shuffles it, and presents it to the user, allowing the user to choose keywords without any fixed bias.

[0186] 4. User-selected keywords:

[0187] The user uses the terminal to select keywords of interest from a presented keyword list, for example, "spicy" and "sushi."

[0188] 5. User keyword vectorization:

[0189] The server vectorizes the keywords selected by the user, setting 1 to the positions where the selected keyword appears and 0 to the other positions.

[0190] 6. Similarity calculation:

[0191] The server calculates the similarity between the user vector and the keyword vector of each dish using cosine similarity, and evaluates the menus and restaurants that are closest to the keywords selected by the user.

[0192] 7. Display of recommendation results:

[0193] The server then lists menus and restaurants in descending order of similarity based on the calculated similarity and displays them to the user. For example, if a user has a high interest in "spicy" and "sushi," menus that match these will be displayed preferentially.

[0194] Hardware and software used

[0195] Hardware: Smartphone

[0196] Software: Python, Pandas, scikit-learn

[0197] Specific examples

[0198] As a concrete example, consider a user opening a food delivery app and selecting "spicy" and "sushi" from a randomly displayed list of keywords. At this step, the prompt text might look like this:

[0199] "Enter keywords for the food you want to choose: (e.g. 'sushi', 'spicy', etc.)"

[0200] The server vectorizes the selected keywords and calculates the cosine similarity to prioritize menu items such as spicy California rolls and spicy tuna rolls. This system allows users to receive personalized meal suggestions based on their interests, providing a more intuitive and satisfying food delivery experience.

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

[0202] Step 1:

[0203] The server collects information about food menus and dining establishments. This step uses a CSV format data file to obtain information such as menu name, description, price, and type of food. The input is food menu information from an external data source, and the output is structured data stored in a database.

[0204] Step 2:

[0205] The server preprocesses the collected text data, converting it to lowercase and removing punctuation. Next, it uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and convert them into a numerical vector. The input is the preprocessed text data, and the output is a numerical vector of keywords. Specifically, it uses Python's Pandas and scikit-learn libraries.

[0206] Step 3:

[0207] The server creates a list of extracted keywords, randomly shuffles it, and presents it to the user. In this step, each keyword in the list is rearranged in a random order. The input is a list of keywords, and the output is a randomized list of keywords.

[0208] Step 4:

[0209] A user uses a terminal to select keywords of interest from a presented keyword list. For example, they can choose "spicy" and "sushi." The input is a randomized keyword list, and the output is a user-selected keyword list.

[0210] Step 5:

[0211] The server vectorizes the keywords selected by the user. In this process, it sets the position of the selected keyword to 1 and other positions to 0. The input is the list of keywords selected by the user, and the output is a numeric vector of the user keywords.

[0212] Step 6:

[0213] The server calculates the similarity between the user vector and the keyword vector of each dish using cosine similarity. In this case, it compares the user vector with the menu vector and measures the angle between each vector. The input is the user vector and the keyword vector of each dish, and the output is a similarity score.

[0214] Step 7:

[0215] The server displays menus and restaurants to the user in descending order of similarity based on the calculated similarity. Specifically, the menus that are closest to the keywords selected by the user are listed at the top. The input is the similarity score, and the output is a list of recommended food menus and restaurants.

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

[0217] As an embodiment of the present invention, a system is provided that extracts keywords from election bulletins and recommends candidates based on the keywords and emotional information selected by voters. This system is configured as follows.

[0218] System Configuration

[0219] 1. Collection of election bulletins

[0220] The server collects the election bulletins of each candidate and stores their campaign promises and policy details in text format. For example, Candidate A's campaign promises include "improving education and increasing housing support."

[0221] 2. Keyword extraction and vectorization

[0222] The server preprocesses the collected text data, lowercasing it and removing punctuation as necessary, then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and represent them as numerical vectors.

[0223] 3. Saving Vector Data

[0224] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each candidate.

[0225] 4. Keyword Randomization

[0226] The server compiles all candidate keywords into a single list and randomly shuffles this list, allowing the user to choose unbiased from the presented keyword list.

[0227] 5. User-selected keywords

[0228] The terminal presents the shuffled keyword list to the user, who then selects some keywords from the list based on his or her own interests.

[0229] 6. Emotion Recognition by Emotion Engine

[0230] The device is equipped with an emotion engine that analyzes the user's facial expressions, voice, and input text, allowing it to recognize the user's emotional state in real time as they select keywords. This information is recorded for later processing.

[0231] 7. Vectorize your selected keywords

[0232] The server runs a process to vectorize the keywords selected by the user: if the selected keyword is in a particular position on the list, it sets that position to 1, and everywhere else it sets it to 0.

[0233] 8. Similarity calculation

[0234] The server calculates the cosine similarity between the user vector and each candidate keyword vector, and then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. This weighted similarity takes into account the influence of the user's emotional state on keyword selection.

[0235] 9. Display of Candidates

[0236] The server sorts the candidates based on the calculated weighted similarity, thereby listing the candidates that are most suitable for the user.

[0237] The device will display candidates to the user in order of similarity. For example, if the user is interested in "education" and "economy," the candidate who best matches those interests and emotional state will be displayed at the top. The user can then decide who to vote for based on this list.

[0238] Specific examples

[0239] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[0240] 1. The user selects "education" and "economy" from a random list of keywords presented to them through their terminal.

[0241] 2. The device analyzes the user's selected emotion (e.g., joy or excitement) using an emotion engine and records the information.

[0242] 3. The server creates a user vector based on these keywords and emotion information.

[0243] 4. The server calculates the weighted cosine similarity between the user vector and the candidate keyword vectors to find the candidate that is closest to the user.

[0244] 5. The server displays candidates in descending order of similarity. For example, if candidate A has the highest similarity, candidate A will be displayed at the top.

[0245] This system allows users to easily find the most suitable candidate based on their interests and emotional state, facilitating voting decisions. Voters can cast their votes based on policy content and their own emotions, promoting a transparent and fair election process.

[0246] The processing flow will be explained below.

[0247] Step 1:

[0248] The server collects election bulletins and stores the contents of each candidate's policies and pledges in text format. For example, the pledge of "Candidate A" is "Improve education and increase housing support."

[0249] Step 2:

[0250] The server formats and preprocesses the collected text data, specifically lowercasing the text and removing punctuation and special characters.

[0251] Step 3:

[0252] The server applies TF-IDF (Term Frequency-Inverse Document Frequency) to the preprocessed text data to extract keywords from each election bulletin. The extracted keywords are expressed as numerical vectors.

[0253] Step 4:

[0254] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each candidate.

[0255] Step 5:

[0256] The server compiles all candidate keywords into a single list and randomly shuffles this list, allowing the user to choose unbiased from the presented keyword list.

[0257] Step 6:

[0258] The terminal presents the shuffled keyword list to the user, who then selects some keywords from the list based on his or her own interests.

[0259] Step 7:

[0260] The device uses an emotion engine that analyzes the user's facial expressions, voice, and input text during keyword selection to recognize the user's emotional state in real time, and this emotional information is recorded for later processing.

[0261] Step 8:

[0262] The server creates a user vector based on the keywords selected by the user. If the selected keyword is in a specific position on the list, it sets that position to 1, and all other positions to 0.

[0263] Step 9:

[0264] The server uses the emotion information and user vector sent from the device to create a weighted user vector that reflects the user's emotional state. This weighted user vector takes into account the influence of the user's emotional state on keyword selection.

[0265] Step 10:

[0266] The server calculates the cosine similarity between the weighted user vector and each candidate keyword vector stored in the database. The cosine similarity is used to measure the angle between the weighted user vector and the candidate vector, and evaluates the similarity as a numerical value.

[0267] Step 11:

[0268] The server sorts the candidates based on the calculated cosine similarity, allowing it to list the candidates most suitable for the user.

[0269] Step 12:

[0270] The device will display candidates to the user in order of similarity. For example, if the user is interested in "education" and "economy," the candidate who best matches those interests and emotional state will be displayed at the top. The user can then decide who to vote for based on this list.

[0271] Example 2

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

[0273] Conventional election support systems have difficulty reflecting the emotional state of voters when selecting candidates based on their own interests. Furthermore, bias is likely to occur in keyword extraction and presentation, making it difficult to ensure fairness in candidate selection. Therefore, there is a growing need for a candidate recommendation system that is fair and reflects emotional states.

[0274] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for saving keyword vectors linked to each candidate in a database, means for randomly presenting the saved keywords, means for vectorizing keywords selected by the user, means for calculating the similarity between the user vector and the candidate vector, means for analyzing and recording the user's emotional state in real time, and means for displaying candidates based on the similarity. This enables voters to fairly select the most suitable candidate based on their interests and emotional state.

[0275] An "election bulletin" is an official document used by each candidate to inform voters of their campaign promises and policies during an election.

[0276] "Keywords" are important words or phrases in election bulletins that indicate the key points of a candidate's campaign promises or policies.

[0277] A "vector" is a format in which a keyword is quantified and expressed as a point in a multidimensional space.

[0278] A "database" is a system that efficiently stores large amounts of information and enables it to be searched and updated.

[0279] "User" refers to the voters who use this system.

[0280] The "similarity" is a numerical value indicating the degree of match between the keyword vector selected by the user and the keyword vector of the candidate.

[0281] "Emotional state" refers to the psychological response of a user when selecting a keyword.

[0282] "Real-time analysis" means processing data and providing results instantly while a user's actions or inputs are occurring.

[0283] As an embodiment of the present invention, we provide a system that extracts keywords from election bulletins and recommends candidates based on the keywords selected by voters and their emotional information. This system functions mainly through the collaboration of three entities: a server, a terminal, and a user.

[0284] The server collects the election bulletins of each candidate and stores their campaign promises and policies in a database in text format. The data is obtained from reliable sources, such as online news sites and the candidate's official website. This data is stored in a structured format for later processing.

[0285] Next, the server preprocesses the collected text data, extracting keywords using TF-IDF (Term Frequency-Inverse Document Frequency) and vectorizing them as numerical vectors. This allows each candidate's campaign promises and policy content to be expressed numerically and made available for calculation. During this process, preprocessing such as lowercasing the text data and removing punctuation marks is performed.

[0286] The server stores the generated keyword vectors in a dedicated database, allowing the keyword vectors for each candidate to be managed in a unified format. The stored data can be used effectively because it quantifies the candidate's characteristics and campaign promises.

[0287] The server then combines all candidate keywords into a single list and randomly shuffles this list, allowing users to fairly choose from the presented keyword list. The shuffled keyword list is then presented to the user via their terminal.

[0288] Users select keywords based on their interests from a shuffled keyword list presented via their device. For example, if a user is interested in "education" and "economy," they select these keywords.

[0289] The terminal is equipped with an emotion engine that analyzes the user's emotional state (e.g., joy or excitement) in real time during selection. This emotion engine analyzes the user's facial expressions, voice, and input text and records the information. This information is used later in the candidate recommendation process.

[0290] The server creates a vector of the keywords selected by the user. In this process, if the selected keyword is in a specific position on the list, it sets that position to 1, and sets other positions to 0. For example, if "education" and "economy" are selected, the corresponding vector will be "[1, 1, 0, 0, ...]".

[0291] The server calculates the cosine similarity between the user vector and each candidate's keyword vector, and then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine, thereby taking into account the impact of the user's emotions on the selection results.

[0292] Finally, the server sorts the candidates based on the calculated weighted similarity. This information is displayed to the user via their device. The user can then decide who to vote for based on this list. For example, if a user is interested in "education" and "economy," the candidates that best match their interests and emotional state will be displayed at the top.

[0293] Specific examples

[0294] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[0295] 1. The user selects "education" and "economy" from a random keyword list presented through the terminal.

[0296] 2. The device analyzes the user's selected emotion (e.g., joy or excitement) using an emotion engine and records the information.

[0297] 3. The server creates a user vector based on these keywords and emotion information. For example, if "education" and "economy" are selected and positive emotion is high, the vector will be "[1, 1, 0, ...]".

[0298] 4. The server calculates the weighted cosine similarity between the user vector and the candidate keyword vector, and finds the candidate who is closest to the user. For example, candidate A with a high similarity is displayed as a number such as "0.85", and candidate B as "0.78".

[0299] 5. The server sorts the candidates in descending order of similarity. For example, if candidate A has the highest similarity, candidate A will be displayed at the top. The terminal displays this to the user, who can then decide who to vote for based on this ordered list.

[0300] The system allows users to easily find the best candidate based on their interests, concerns and emotional state, making voting decisions easier.

[0301] Example prompts for generative AI models

[0302] "The keywords I'm interested in are 'education' and 'economy.' Based on these, please explain a candidate recommendation system that includes emotional information."

[0303] "Please tell me in detail the process flow of a specific system that uses user-selected keywords and emotional state to recommend candidates."

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

[0305] Step 1:

[0306] The server automatically collects each candidate's election bulletin from the Internet and other reliable sources. The collected data is stored in a database in text format. For example, Candidate A's campaign promise "Improve education and increase housing support" is saved as a text file. The input is the election bulletin data from the Internet, and the output is the text data stored in the database.

[0307] Step 2:

[0308] The server preprocesses the stored text data. During this process, the text is converted to lowercase and punctuation and unnecessary whitespace are removed. Next, the TF-IDF algorithm is used to extract important keywords and vectorize them into numerical vectors. For example, if "education" appears frequently and is important, it will be given a high score. The input is the stored text data, and the output is the vectorized keywords.

[0309] Step 3:

[0310] The server stores the generated keyword vectors in a database. This allows the keyword vectors for each candidate to be managed in a unified format. The stored data is used for subsequent processing, as it quantifies and stores the candidate's characteristics and campaign promises. The input is the vectorized keywords, and the output is the keyword vector stored in the database.

[0311] Step 4:

[0312] The server compiles all candidate keywords into a single list and randomly shuffles this list. This allows users to fairly choose from the presented keyword list. The shuffled keyword list is sent to the terminal and displayed. The input is the keywords of all candidates retrieved from the database, and the output is a randomly shuffled keyword list.

[0313] Step 5:

[0314] The terminal presents the shuffled keyword list to the user. The user selects keywords based on their own interests. For example, if the user is interested in "education" and "economy," they select those keywords. The input is the shuffled keyword list, and the output is the keywords selected by the user.

[0315] Step 6:

[0316] The device analyzes and records the user's emotional state during selection in real time using an emotion engine that analyzes facial expressions, voice, and input text. For example, if the user smiles while selecting "Education," it will be recorded as a positive emotion. The input is the user's facial expressions, voice, and input text, and the output is the recorded emotional information.

[0317] Step 7:

[0318] The server vectorizes the keywords selected by the user. In this process, if the selected keyword exists in a specific position on the list, it sets that position to 1 and sets other positions to 0. For example, if "education" and "economy" are selected, the corresponding vector will be "[1, 1, 0, 0, ...]". The input is the keyword selected by the user, and the output is the vectorized keyword.

[0319] Step 8:

[0320] The server calculates the cosine similarity between the user vector and each candidate's keyword vector. It then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. The inputs are the user vector, each candidate's vector, and the emotion information, and the output is the calculated weighted cosine similarity.

[0321] Step 9:

[0322] The server sorts each candidate in descending order of similarity based on the calculated weighted similarity. This information is displayed to the user through the terminal. For example, if the user is interested in "education" and "economy," the candidates who best match those interests and emotional state are displayed at the top. The input is the calculated weighted similarity, and the output is a list of candidates sorted in descending order of similarity.

[0323] (Application example 2)

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

[0325] In Internet shopping and electronic payments, it is difficult for users to find the best products and services based on their own interests. In particular, recommendation systems that ignore users' emotional information cannot provide products that truly meet their needs. Furthermore, users may become overwhelmed by the large amount of information available, making it difficult for them to make appropriate decisions. This poses a challenge in terms of improving user satisfaction and stimulating purchasing motivation.

[0326] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for saving keyword vectors linked to each candidate in a database, means for randomly presenting the saved keywords, means for vectorizing keywords selected by the user, means for analyzing the user's emotional information in real time, means for calculating the similarity between the user vector and the candidate vector and evaluating the weighted similarity that reflects the emotional information, and means for displaying candidates based on the similarity. This makes it possible to recommend optimal products and services that take into account the user's emotional state as well as their interests and concerns.

[0327] An "election bulletin" is a document containing campaign promises and policies announced by an election candidate.

[0328] "Keywords" are important words or phrases extracted from text data.

[0329] "Vectorization" is the process of converting text data into numerical vectors.

[0330] A "database" is a system for storing and managing data in an organized manner.

[0331] "Random presentation" means that saved keywords are randomly selected and displayed.

[0332] "User" refers to a person who uses the system.

[0333] "Emotion information" is data that indicates the emotional state that the user experiences during selection or operation.

[0334] "Real-time analysis" refers to the process of analyzing data immediately without delay.

[0335] "Similarity" is a value that indicates the similarity between two vectors.

[0336] "Weighted similarity" is a similarity that is adjusted taking into account emotional information.

[0337] "Recommend" means suggesting the best options to the user.

[0338] As an embodiment of the present invention, a system is provided that recommends optimal products and services to a user while taking into consideration emotional information of the user. This system is configured as follows.

[0339] System Configuration

[0340] 1. Server

[0341] The server collects product and service descriptions and stores them in text format, such as "Innovative Devices and Software for Education" or "Latest Economic News and Market Analysis."

[0342] 2. Keyword extraction and vectorization

[0343] The server preprocesses the collected text data, lowercasing it and removing punctuation as necessary. It then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and represent them as numerical vectors. For example, the Python library scikit-learn can be used for this process.

[0344] 3. Saving Vector Data

[0345] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each product. The database can be MySQL, MongoDB, or similar.

[0346] 4. Keyword Randomization

[0347] The server aggregates all product keywords into a single list and randomly shuffles this list, allowing the user to choose unbiased from the presented keyword list.

[0348] 5. User-selected keywords

[0349] The device presents a shuffled keyword list to the user, who then selects several keywords from the list based on their own interests. The device can be a smartphone or tablet.

[0350] 6. Emotion Recognition by Emotion Engine

[0351] The device is equipped with an emotion engine that analyzes the user's facial expressions, voice, and input text. This allows it to recognize the user's emotional state in real time when selecting keywords. This information is recorded for later processing. The emotion engine can be EmotionEngine (a virtual library).

[0352] 7. Vectorize your selected keywords

[0353] The server runs a process to vectorize the keywords selected by the user. If the selected keyword is in a specific position on the list, it sets that position to 1, and all other positions to 0. This process can also be done using scikit-learn.

[0354] 8. Similarity calculation

[0355] The server calculates the cosine similarity between the user vector and each product's keyword vector. It then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. This weighted similarity takes into account the influence of the user's emotional state on keyword selection.

[0356] 9. Product Display

[0357] The server sorts products and services in descending order of similarity based on the calculated weighted similarity. This allows it to create a list of products and services that are most suitable for the user. The device displays products and services to the user in descending order of similarity. For example, if the user is interested in "education" and "economy," the device will display products and services that best match those interests and emotional state at the top. The user can make their purchasing decisions based on this list.

[0358] Specific examples

[0359] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[0360] 1. The user selects "education" and "economy" from a random list of keywords presented to them through their terminal.

[0361] 2. The device analyzes the user's selected emotion (e.g., joy or excitement) using an emotion engine and records the information.

[0362] 3. The server creates a user vector based on these keywords and emotion information.

[0363] 4. The server calculates the weighted cosine similarity between the user vector and the keyword vector of the product or service, and finds the product or service that is closest to the user.

[0364] 5. The server displays products and services in order of similarity. For example, if educational devices or economic news analysis have the highest similarity, they will be displayed at the top.

[0365] Specific input prompt examples:

[0366] "The user expressed interest in 'education' and 'economy' while browsing the page. The emotion engine detected joy. Use this to recommend products."

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

[0368] Step 1: Collect election bulletins (product description data)

[0369] The server collects the description data for each product and stores it in text format. During this process, the server retrieves data from various databases and websites on the Internet. The input is the product description data itself, and the output is the stored text data.

[0370] Step 2: Keyword extraction and vectorization

[0371] The server preprocesses the collected text data, lowercasing it and removing punctuation as needed. Then, it uses TF-IDF to extract important keywords from the text and express them as a numerical vector. The input is the preprocessed text data, and the output is a keyword vector.

[0372] Step 3: Save the vector data

[0373] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each product. The input is the keyword vector, and the output is the vector data stored in the database.

[0374] Step 4: Randomize Keywords

[0375] The server collects all product keywords into a single list and randomly shuffles this list. Shuffling allows the user to choose from the presented keyword list without bias. The input is the stored keyword list, and the output is the randomly shuffled keyword list.

[0376] Step 5: User-selected keywords

[0377] The terminal presents a shuffled list of keywords to the user. The user selects some keywords from the presented list based on their own interests. The input is the randomized keyword list, and the output is the keywords selected by the user.

[0378] Step 6: Emotion Recognition with the Emotion Engine

[0379] The device uses an emotion engine that analyzes the user's facial expressions, voice, and input text to recognize the user's emotional state in real time when selecting keywords. This information is recorded for later processing. The input is emotional information such as the user's voice, facial expressions, and text, and the output is analyzed emotional data.

[0380] Step 7: Vectorize your chosen keywords

[0381] The server runs a process to vectorize the user-selected keywords. If the selected keyword is in a particular position on the list, it sets that position to 1, and all other positions to 0. The input is the user-selected keyword, and the output is the user vector.

[0382] Step 8: Similarity calculation

[0383] The server calculates the cosine similarity between the user vector and the keyword vector of the product. It then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. This weighted similarity takes into account the impact of the user's emotional state on keyword selection. The inputs are the user vector, product vector, and emotion data, and the output is the weighted similarity.

[0384] Step 9: Display your products

[0385] The server sorts products and services in descending order of similarity based on the calculated weighted similarity, and the terminal displays the products and services to the user in descending order of similarity. The input is the weighted similarity and product data, and the output is a product list presented to the user.

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

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

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

[0389] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0402] As an embodiment of the present invention, a system is provided that extracts keywords from election bulletins and allows voters to select candidates based on their own interests. This system is configured as follows.

[0403] 1. Collection of election bulletins

[0404] The server collects the election bulletins of each candidate and stores their campaign promises and policy details in text format. For example, Candidate A's campaign promises include "improving education and increasing housing support."

[0405] 2. Keyword extraction and vectorization

[0406] The server preprocesses the collected text data, converting it to lowercase and removing punctuation as necessary. It then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and convert them into numerical vectors. This allows the importance of each keyword to be expressed as a number.

[0407] 3. Saving Vector Data

[0408] The server stores the generated keyword vectors in a database, which allows the policies and pledges of each candidate to be managed as numerical data.

[0409] 4. Keyword Randomization

[0410] The server compiles all candidate keywords into a single list and randomly shuffles it. Randomization allows users to choose keywords without any fixed bias.

[0411] 5. User-selected keywords

[0412] The user uses the terminal to select keywords that interest them from the presented keyword list, for example, "education" and "economy."

[0413] 6. Vectorize the selected keywords

[0414] The server runs a process to vectorize the keywords selected by the user, using the simple method of setting a 1 in positions where the selected keyword occurs and a 0 in other positions.

[0415] 7. Similarity calculation

[0416] The server calculates the similarity between the user vector and each candidate's keyword vector. It uses cosine similarity to measure the similarity between each vector as a number. This similarity calculation evaluates which candidate is closest to the user's chosen keywords.

[0417] 8. Display of Candidates

[0418] The server sorts the candidates based on the calculated similarity. Finally, the list is displayed to the user in order of the candidates who are closest to the user's own beliefs. For example, if the user has a strong interest in "education" and "economy," candidates who match these interests will be displayed first.

[0419] Specific examples

[0420] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[0421] Through the terminal, the user selects "education" and "economy" from a random list of keywords presented to them.

[0422] The server creates a user vector based on these keywords.

[0423] The server calculates the cosine similarity between the user vector and the candidate's keyword vector to find the candidate that is closest to the user.

[0424] The server displays candidates in descending order of similarity, and for example, if candidate A has the highest similarity, candidate A will be displayed at the top.

[0425] The system allows users to easily find the most suitable candidates based on their interests, facilitating voting decisions, allowing voters to cast their votes based on policy content, promoting a transparent and fair election process.

[0426] The processing flow will be explained below.

[0427] Step 1:

[0428] The server collects election bulletins and stores the contents of each candidate's policies and pledges in text format. For example, the pledges of "Candidate A" include "improving education and increasing housing support."

[0429] Step 2:

[0430] The server formats and preprocesses the collected text data, specifically lowercasing the text and removing punctuation and special characters.

[0431] Step 3:

[0432] The server applies TF-IDF (Term Frequency-Inverse Document Frequency) to the preprocessed text data to extract keywords from each election bulletin. The extracted keywords are expressed as numerical vectors.

[0433] Step 4:

[0434] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each candidate.

[0435] Step 5:

[0436] The server compiles all candidate keywords into a single list and randomly shuffles this list, allowing voters to choose unbiased from the presented keyword list.

[0437] Step 6:

[0438] The terminal presents the shuffled keyword list to the user, who then selects some keywords from the list based on his or her own interests.

[0439] Step 7:

[0440] The server creates a user vector based on the keywords selected by the user. For example, if the selected keyword is in a specific position on the list, it sets that position to 1, and all other positions to 0.

[0441] Step 8:

[0442] The server calculates the cosine similarity between the created user vector and each candidate keyword vector stored in the database. Using the cosine similarity, the angle between the user vector and the candidate vector is measured and the similarity is evaluated as a numerical value.

[0443] Step 9:

[0444] The server sorts the candidates based on the calculated cosine similarity, allowing it to list the candidates most suitable for the user.

[0445] Step 10:

[0446] The device will display candidates to the user in order of similarity. For example, if the user is interested in "education" and "economy," the candidate who best matches those interests will be displayed at the top. The user can then decide who to vote for based on this list.

[0447] Example 1

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

[0449] Conventional election information systems make it difficult for voters to obtain detailed information about candidates' pledges and policies in a centralized manner and select the appropriate candidate based on their own interests. Furthermore, there was a lack of improved accuracy in keyword extraction and vectorization, as well as automated data collection methods, which could potentially compromise the transparency and fairness of election information. There was a need to provide a system that would solve these issues and enable voters to select candidates efficiently and fairly.

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

[0451] In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for storing keyword vectors associated with each candidate in a database, means for randomly presenting the stored keywords, means for vectorizing keywords selected by a user, means for calculating the similarity between a user vector and a candidate vector, means for displaying candidates based on the similarity, means for automating the collection of election bulletin data, means for randomly displaying keywords selected by a user, and means for preprocessing keyword data by lowercasing and removing punctuation. This enables voters to efficiently select candidates based on their interests, improving the transparency and fairness of election information.

[0452] An "election bulletin" is an official document published by each candidate in an election to communicate their campaign promises and policies to voters.

[0453] "Keyword extraction methods" are techniques and algorithms used to extract important words and phrases from election bulletins.

[0454] "Vectorization" is the process of converting keywords or text data into numerical vectors, making them computable.

[0455] "Means for storing in a database" refers to a technology or system for efficiently storing the generated keyword vectors so that they can be easily searched and accessed later.

[0456] A "random presentation method" is a technique or algorithm for randomly rearranging keywords and presenting them to the user without relying on a specific order.

[0457] The "means for vectorizing user-selected keywords" is a process for converting user-selected keywords into numerical vectors, making them comparable with other data.

[0458] The "means for calculating similarity" refers to a technique or algorithm for numerically indicating the similarity between a user vector and a candidate vector and for making an evaluation based on that numerical value.

[0459] The "means for displaying candidates" refers to a technology or system for sorting candidates based on the calculated similarity and visually presenting them to the user.

[0460] "Means for automating the collection of election bulletin data" refers to web scraping and data mining technologies for efficiently and automatically collecting election bulletin data.

[0461] "Means for lowercasing and removing punctuation marks as preprocessing of keyword data" refers to techniques and processes for lowercasing and removing unnecessary punctuation marks to make text data easier to analyze.

[0462] This invention provides a system that extracts keywords from election bulletins and allows voters to select candidates based on their interests. This system consists of three main components: a server, a terminal, and a user.

[0463] The server first collects election bulletin data. Specifically, it uses web scraping technology (for example, Python's BeautifulSoup library) to obtain election bulletins from the official website of the Election Commission and each candidate's website, and saves them in text format. The saved text data is then preprocessed using natural language processing libraries such as NLTK and spaCy. Preprocessing includes lowercasing and removing punctuation.

[0464] Next, the server extracts important keywords from the preprocessed text data using TF-IDF and converts them into numerical vectors using the scikit-learn library. This vector data is then stored in a database (e.g., MySQL or PostgreSQL).

[0465] The server then combines all candidate keyword lists into a single list and randomly shuffles it using Python's random library, ready to be presented to the user.

[0466] Users select keywords that interest them from a random keyword list presented to them using their device (PC or smartphone). The selected keywords are then vectorized by the server using one-hot encoding technology.

[0467] Next, the server calculates the cosine similarity between the keyword vector selected by the user and the keyword vector of each candidate, again using the scikit-learn library. Based on the calculated similarity, the candidates are sorted in order of their proximity to the user's interests.

[0468] Finally, the server displays the results of the similarity calculation to the user via their terminal, and the user can select the most suitable candidate based on the presented information.

[0469] As a specific example, consider the case where a user is interested in "education" and "economy."

[0470] 1. The server collects and preprocesses election bulletin data.

[0471] 2. The server extracts important keywords and vectorizes them. In this case, for example, "education" and "economy" are extracted.

[0472] 3. The server randomly shuffles all candidate keywords and presents them to the user.

[0473] 4. The user selects "education" and "economy" from the presented keyword list.

[0474] 5. The server creates a user vector based on the user's selection and calculates the similarity with each candidate's vector using cosine similarity.

[0475] 6. The server sorts the candidates based on similarity and displays them to the user via their device. The user then makes a voting decision based on the displayed list of candidates.

[0476] This system allows users to select candidates efficiently and fairly.

[0477] Prompt example

[0478] "Please extract policy keywords related to education and the economy from the latest election bulletins and recommend candidates based on those."

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

[0480] System program processing flow

[0481] Step 1: Collect election information

[0482] The server periodically collects election bulletin data from the official website of the Election Commission and each candidate's website. Specifically, it uses Python's BeautifulSoup library to scrape web pages and obtains candidates' campaign promises and policy details in text format.

[0483] Input: URL of the web page where the election bulletin is published

[0484] Output: Candidate pledge data in text format

[0485] Specific operation: HTML parsing and text extraction using BeautifulSoup

[0486] Step 2: Keyword extraction and preprocessing

[0487] The server preprocesses the collected text data by using Python's NLTK and spaCy to lowercase the text and remove punctuation and special characters, and then uses the TF-IDF method to extract important keywords.

[0488] Input: Candidate pledge data in text format

[0489] Output: Preprocessed text data and important keywords

[0490] Specific operation: Preprocessing using NLTK and spaCy (lowercasing, punctuation removal), keyword extraction using TF-IDF

[0491] Step 3: Vectorize keywords

[0492] The server vectorizes the keywords extracted from the preprocessed text data using the scikit-learn library. Based on the TF-IDF score, the importance of each keyword is expressed as a numerical vector.

[0493] Input: Preprocessed text data and important keywords

[0494] Output: TF-IDF based keyword vectors

[0495] Specific operation: TF-IDF score calculation and vectorization

[0496] Step 4: Save the vector data

[0497] The server stores the generated keyword vectors in a database (e.g., MySQL or PostgreSQL). A keyword vector is saved for each candidate, allowing for easy searching and access later.

[0498] Input: TF-IDF based keyword vectors

[0499] Output: Keyword vectors stored in a database

[0500] Specific operation: Write operation to database

[0501] Step 5: Randomize Keywords

[0502] The server compiles all candidate keyword lists into a single list and randomly shuffles them using Python's random library, which is then presented to the user.

[0503] Input: Keyword vectors stored in a database

[0504] Output: Randomly shuffled keyword list

[0505] Specific operation: Shuffling using the Random library

[0506] Step 6: User-selected keywords

[0507] Users use their devices (PCs or smartphones) to select keywords that interest them from a randomly arranged keyword list by clicking or tapping on the screen.

[0508] Input: Randomly shuffled keyword list

[0509] Output: User selected keywords

[0510] Specific action: Keyword selection through the user interface

[0511] Step 7: Vectorize your chosen keywords

[0512] The server vectorizes the keywords selected by the user using one-hot encoding, which sets 1 to the vector position corresponding to the selected keyword and 0 to the other positions.

[0513] Input: User-selected keywords

[0514] Output: User vectors by one-hot encoding

[0515] Specific operation: Vectorization of user keywords (one-hot encoding)

[0516] Step 8: Similarity calculation

[0517] The server calculates the similarity between the user vector and each candidate's keyword vector, using the cosine_similarity function from the scikit-learn library.

[0518] Input: User vectors obtained by one-hot encoding, candidate keyword vectors stored in the database

[0519] Output: Cosine similarity with each candidate

[0520] Specific operation: Calculating cosine similarity (cosine_similarity in scikit-learn)

[0521] Step 9: View candidates

[0522] The server sorts the candidates based on the calculated similarity and displays them on the user's device in order of the most similar. The user then makes a voting decision based on the information presented.

[0523] Input: Cosine similarity with each candidate

[0524] Output: A list of candidates based on similarity

[0525] Specific behavior: Displaying a list of candidates through a user interface

[0526] Prompt example

[0527] "Please extract policy keywords related to education and the economy from the latest election bulletins and recommend candidates based on those."

[0528] (Application example 1)

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

[0530] Current food delivery systems provide a wide range of menus and restaurant information, but it is difficult for users to select the most suitable dishes and dining establishments based on their interests. In addition, when users search for menus or restaurants based on specific keywords, bias is likely to occur, making it difficult to obtain truly personalized suggestions.

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

[0532] In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for storing keyword vectors associated with each candidate in a database, means for randomly presenting the stored keywords, means for vectorizing keywords selected by the user, means for calculating the similarity between the user vector and the candidate vector, means for displaying candidates based on the similarity, means for collecting information on food menus and dining establishments, extracting and vectorizing keywords from menu descriptions, and means for recommending food menus and dining establishments based on the keywords selected by the user, thereby enabling users to receive personalized meal suggestions based on their interests.

[0533] An "election bulletin" is an official document in which a candidate outlines his or her policies and positions during the election campaign.

[0534] "Keywords" are words or phrases that summarize and highlight a particular context or piece of information.

[0535] "Vectorization" is the process of converting non-numeric information, such as text data, into numerical vectors, making them analyzable.

[0536] A "database" is a system for efficiently storing, managing, and searching structured data.

[0537] "Random presentation" means presenting information randomly, without any particular order or regularity.

[0538] "Similarity" is a measure of the relative closeness or relatedness between two objects.

[0539] A "food menu" is a list of the foods and drinks served at a food establishment.

[0540] "Food and beverage establishment" means a facility for serving food and beverages.

[0541] "Extraction" is the process of selecting specific information or elements from the original data set.

[0542] "TF-IDF" stands for Term Frequency-Inverse Document Frequency and is a statistical method for measuring the importance of words in a document.

[0543] "Cosine similarity" is a method for measuring the similarity between two vectors using the angle between them.

[0544] The present invention is a food delivery system that allows users to find the most suitable food menu and dining establishment based on their interests. A specific example of the system is described below.

[0545] 1. Data Collection:

[0546] The server collects information about food menus and restaurants, including menu names, descriptions, prices, and types of food. This data is saved as a data file in CSV format or similar.

[0547] 2. Keyword extraction and vectorization:

[0548] The server preprocesses the collected text data, converting it to lowercase and removing punctuation. It then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and convert them into numerical vectors. This process uses the Python libraries scikit-learn and Pandas.

[0549] 3. Random keyword suggestions:

[0550] The server creates a list of extracted keywords, randomly shuffles it, and presents it to the user, allowing the user to choose keywords without any fixed bias.

[0551] 4. User-selected keywords:

[0552] The user uses the terminal to select keywords of interest from a presented keyword list, for example, "spicy" and "sushi."

[0553] 5. User keyword vectorization:

[0554] The server vectorizes the keywords selected by the user, setting 1 to the positions where the selected keyword appears and 0 to the other positions.

[0555] 6. Similarity calculation:

[0556] The server calculates the similarity between the user vector and the keyword vector of each dish using cosine similarity, and evaluates the menus and restaurants that are closest to the keywords selected by the user.

[0557] 7. Display of recommendation results:

[0558] The server then lists menus and restaurants in descending order of similarity based on the calculated similarity and displays them to the user. For example, if a user has a high interest in "spicy" and "sushi," menus that match these will be displayed preferentially.

[0559] Hardware and software used

[0560] Hardware: Smartphone

[0561] Software: Python, Pandas, scikit-learn

[0562] Specific examples

[0563] As a concrete example, consider a user opening a food delivery app and selecting "spicy" and "sushi" from a randomly displayed list of keywords. At this step, the prompt text might look like this:

[0564] "Enter keywords for the food you want to choose: (e.g. 'sushi', 'spicy', etc.)"

[0565] The server vectorizes the selected keywords and calculates the cosine similarity to prioritize menu items such as spicy California rolls and spicy tuna rolls. This system allows users to receive personalized meal suggestions based on their interests, providing a more intuitive and satisfying food delivery experience.

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

[0567] Step 1:

[0568] The server collects information about food menus and dining establishments. This step uses a CSV format data file to obtain information such as menu name, description, price, and type of food. The input is food menu information from an external data source, and the output is structured data stored in a database.

[0569] Step 2:

[0570] The server preprocesses the collected text data, converting it to lowercase and removing punctuation. Next, it uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and convert them into a numerical vector. The input is the preprocessed text data, and the output is a numerical vector of keywords. Specifically, it uses Python's Pandas and scikit-learn libraries.

[0571] Step 3:

[0572] The server creates a list of extracted keywords, randomly shuffles it, and presents it to the user. In this step, each keyword in the list is rearranged in a random order. The input is a list of keywords, and the output is a randomized list of keywords.

[0573] Step 4:

[0574] A user uses a terminal to select keywords of interest from a presented keyword list. For example, they can choose "spicy" and "sushi." The input is a randomized keyword list, and the output is a user-selected keyword list.

[0575] Step 5:

[0576] The server vectorizes the keywords selected by the user. In this process, it sets the position of the selected keyword to 1 and other positions to 0. The input is the list of keywords selected by the user, and the output is a numeric vector of the user keywords.

[0577] Step 6:

[0578] The server calculates the similarity between the user vector and the keyword vector of each dish using cosine similarity. In this case, it compares the user vector with the menu vector and measures the angle between each vector. The input is the user vector and the keyword vector of each dish, and the output is a similarity score.

[0579] Step 7:

[0580] The server displays menus and restaurants to the user in descending order of similarity based on the calculated similarity. Specifically, the menus that are closest to the keywords selected by the user are listed at the top. The input is the similarity score, and the output is a list of recommended food menus and restaurants.

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

[0582] As an embodiment of the present invention, a system is provided that extracts keywords from election bulletins and recommends candidates based on the keywords and emotional information selected by voters. This system is configured as follows.

[0583] System Configuration

[0584] 1. Collection of election bulletins

[0585] The server collects the election bulletins of each candidate and stores their campaign promises and policy details in text format. For example, Candidate A's campaign promises include "improving education and increasing housing support."

[0586] 2. Keyword extraction and vectorization

[0587] The server preprocesses the collected text data, lowercasing it and removing punctuation as necessary, then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and represent them as numerical vectors.

[0588] 3. Saving Vector Data

[0589] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each candidate.

[0590] 4. Keyword Randomization

[0591] The server compiles all candidate keywords into a single list and randomly shuffles this list, allowing the user to choose unbiased from the presented keyword list.

[0592] 5. User-selected keywords

[0593] The terminal presents the shuffled keyword list to the user, who then selects some keywords from the list based on his or her own interests.

[0594] 6. Emotion Recognition by Emotion Engine

[0595] The device is equipped with an emotion engine that analyzes the user's facial expressions, voice, and input text, allowing it to recognize the user's emotional state in real time as they select keywords. This information is recorded for later processing.

[0596] 7. Vectorize your selected keywords

[0597] The server runs a process to vectorize the keywords selected by the user: if the selected keyword is in a particular position on the list, it sets that position to 1, and everywhere else it sets it to 0.

[0598] 8. Similarity calculation

[0599] The server calculates the cosine similarity between the user vector and each candidate keyword vector, and then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. This weighted similarity takes into account the influence of the user's emotional state on keyword selection.

[0600] 9. Display of Candidates

[0601] The server sorts the candidates based on the calculated weighted similarity, thereby listing the candidates that are most suitable for the user.

[0602] The device will display candidates to the user in order of similarity. For example, if the user is interested in "education" and "economy," the candidate who best matches those interests and emotional state will be displayed at the top. The user can then decide who to vote for based on this list.

[0603] Specific examples

[0604] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[0605] 1. The user selects "education" and "economy" from a random list of keywords presented to them through their terminal.

[0606] 2. The device analyzes the user's selected emotion (e.g., joy or excitement) using an emotion engine and records the information.

[0607] 3. The server creates a user vector based on these keywords and emotion information.

[0608] 4. The server calculates the weighted cosine similarity between the user vector and the candidate keyword vectors to find the candidate that is closest to the user.

[0609] 5. The server displays candidates in descending order of similarity. For example, if candidate A has the highest similarity, candidate A will be displayed at the top.

[0610] This system allows users to easily find the most suitable candidate based on their interests and emotional state, facilitating voting decisions. Voters can cast their votes based on policy content and their own emotions, promoting a transparent and fair election process.

[0611] The processing flow will be explained below.

[0612] Step 1:

[0613] The server collects election bulletins and stores the contents of each candidate's policies and pledges in text format. For example, the pledge of "Candidate A" is "Improve education and increase housing support."

[0614] Step 2:

[0615] The server formats and preprocesses the collected text data, specifically lowercasing the text and removing punctuation and special characters.

[0616] Step 3:

[0617] The server applies TF-IDF (Term Frequency-Inverse Document Frequency) to the preprocessed text data to extract keywords from each election bulletin. The extracted keywords are expressed as numerical vectors.

[0618] Step 4:

[0619] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each candidate.

[0620] Step 5:

[0621] The server compiles all candidate keywords into a single list and randomly shuffles this list, allowing the user to choose unbiased from the presented keyword list.

[0622] Step 6:

[0623] The terminal presents the shuffled keyword list to the user, who then selects some keywords from the list based on his or her own interests.

[0624] Step 7:

[0625] The device uses an emotion engine that analyzes the user's facial expressions, voice, and input text during keyword selection to recognize the user's emotional state in real time, and this emotional information is recorded for later processing.

[0626] Step 8:

[0627] The server creates a user vector based on the keywords selected by the user. If the selected keyword is in a specific position on the list, it sets that position to 1, and all other positions to 0.

[0628] Step 9:

[0629] The server uses the emotion information and user vector sent from the device to create a weighted user vector that reflects the user's emotional state. This weighted user vector takes into account the influence of the user's emotional state on keyword selection.

[0630] Step 10:

[0631] The server calculates the cosine similarity between the weighted user vector and each candidate keyword vector stored in the database. The cosine similarity is used to measure the angle between the weighted user vector and the candidate vector, and evaluates the similarity as a numerical value.

[0632] Step 11:

[0633] The server sorts the candidates based on the calculated cosine similarity, allowing it to list the candidates most suitable for the user.

[0634] Step 12:

[0635] The device will display candidates to the user in order of similarity. For example, if the user is interested in "education" and "economy," the candidate who best matches those interests and emotional state will be displayed at the top. The user can then decide who to vote for based on this list.

[0636] Example 2

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

[0638] Conventional election support systems have difficulty reflecting the emotional state of voters when selecting candidates based on their own interests. Furthermore, bias is likely to occur in keyword extraction and presentation, making it difficult to ensure fairness in candidate selection. Therefore, there is a growing need for a candidate recommendation system that is fair and reflects emotional states.

[0639] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for saving keyword vectors linked to each candidate in a database, means for randomly presenting the saved keywords, means for vectorizing keywords selected by the user, means for calculating the similarity between the user vector and the candidate vector, means for analyzing and recording the user's emotional state in real time, and means for displaying candidates based on the similarity. This enables voters to fairly select the most suitable candidate based on their interests and emotional state.

[0640] An "election bulletin" is an official document used by each candidate to inform voters of their campaign promises and policies during an election.

[0641] "Keywords" are important words or phrases in election bulletins that indicate the key points of a candidate's campaign promises or policies.

[0642] A "vector" is a format in which a keyword is quantified and expressed as a point in a multidimensional space.

[0643] A "database" is a system that efficiently stores large amounts of information and enables it to be searched and updated.

[0644] "User" refers to the voters who use this system.

[0645] The "similarity" is a numerical value indicating the degree of match between the keyword vector selected by the user and the keyword vector of the candidate.

[0646] "Emotional state" refers to the psychological response of a user when selecting a keyword.

[0647] "Real-time analysis" means processing data and providing results instantly while a user's actions or inputs are occurring.

[0648] As an embodiment of the present invention, we provide a system that extracts keywords from election bulletins and recommends candidates based on the keywords selected by voters and their emotional information. This system functions mainly through the collaboration of three entities: a server, a terminal, and a user.

[0649] The server collects the election bulletins of each candidate and stores their campaign promises and policies in a database in text format. The data is obtained from reliable sources, such as online news sites and the candidate's official website. This data is stored in a structured format for later processing.

[0650] Next, the server preprocesses the collected text data, extracting keywords using TF-IDF (Term Frequency-Inverse Document Frequency) and vectorizing them as numerical vectors. This allows each candidate's campaign promises and policy content to be expressed numerically and made available for calculation. During this process, preprocessing such as lowercasing the text data and removing punctuation marks is performed.

[0651] The server stores the generated keyword vectors in a dedicated database, allowing the keyword vectors for each candidate to be managed in a unified format. The stored data can be used effectively because it quantifies the candidate's characteristics and campaign promises.

[0652] The server then combines all candidate keywords into a single list and randomly shuffles this list, allowing users to fairly choose from the presented keyword list. The shuffled keyword list is then presented to the user via their terminal.

[0653] Users select keywords based on their interests from a shuffled keyword list presented via their device. For example, if a user is interested in "education" and "economy," they select these keywords.

[0654] The terminal is equipped with an emotion engine that analyzes the user's emotional state (e.g., joy or excitement) in real time during selection. This emotion engine analyzes the user's facial expressions, voice, and input text and records the information. This information is used later in the candidate recommendation process.

[0655] The server creates a vector of the keywords selected by the user. In this process, if the selected keyword is in a specific position on the list, it sets that position to 1, and sets other positions to 0. For example, if "education" and "economy" are selected, the corresponding vector will be "[1, 1, 0, 0, ...]".

[0656] The server calculates the cosine similarity between the user vector and each candidate's keyword vector, and then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine, thereby taking into account the impact of the user's emotions on the selection results.

[0657] Finally, the server sorts the candidates based on the calculated weighted similarity. This information is displayed to the user via their device. The user can then decide who to vote for based on this list. For example, if a user is interested in "education" and "economy," the candidates that best match their interests and emotional state will be displayed at the top.

[0658] Specific examples

[0659] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[0660] 1. The user selects "education" and "economy" from a random keyword list presented through the terminal.

[0661] 2. The device analyzes the user's selected emotion (e.g., joy or excitement) using an emotion engine and records the information.

[0662] 3. The server creates a user vector based on these keywords and emotion information. For example, if "education" and "economy" are selected and positive emotion is high, the vector will be "[1, 1, 0, ...]".

[0663] 4. The server calculates the weighted cosine similarity between the user vector and the candidate keyword vector, and finds the candidate who is closest to the user. For example, candidate A with a high similarity is displayed as a number such as "0.85", and candidate B as "0.78".

[0664] 5. The server sorts the candidates in descending order of similarity. For example, if candidate A has the highest similarity, candidate A will be displayed at the top. The terminal displays this to the user, who can then decide who to vote for based on this ordered list.

[0665] The system allows users to easily find the best candidate based on their interests, concerns and emotional state, making voting decisions easier.

[0666] Example prompts for generative AI models

[0667] "The keywords I'm interested in are 'education' and 'economy.' Based on these, please explain a candidate recommendation system that includes emotional information."

[0668] "Please tell me in detail the process flow of a specific system that uses user-selected keywords and emotional state to recommend candidates."

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

[0670] Step 1:

[0671] The server automatically collects each candidate's election bulletin from the Internet and other reliable sources. The collected data is stored in a database in text format. For example, Candidate A's campaign promise "Improve education and increase housing support" is saved as a text file. The input is the election bulletin data from the Internet, and the output is the text data stored in the database.

[0672] Step 2:

[0673] The server preprocesses the stored text data. During this process, the text is converted to lowercase and punctuation and unnecessary whitespace are removed. Next, the TF-IDF algorithm is used to extract important keywords and vectorize them into numerical vectors. For example, if "education" appears frequently and is important, it will be given a high score. The input is the stored text data, and the output is the vectorized keywords.

[0674] Step 3:

[0675] The server stores the generated keyword vectors in a database. This allows the keyword vectors for each candidate to be managed in a unified format. The stored data is used for subsequent processing, as it quantifies and stores the candidate's characteristics and campaign promises. The input is the vectorized keywords, and the output is the keyword vector stored in the database.

[0676] Step 4:

[0677] The server compiles all candidate keywords into a single list and randomly shuffles this list. This allows users to fairly choose from the presented keyword list. The shuffled keyword list is sent to the terminal and displayed. The input is the keywords of all candidates retrieved from the database, and the output is a randomly shuffled keyword list.

[0678] Step 5:

[0679] The terminal presents the shuffled keyword list to the user. The user selects keywords based on their own interests. For example, if the user is interested in "education" and "economy," they select those keywords. The input is the shuffled keyword list, and the output is the keywords selected by the user.

[0680] Step 6:

[0681] The device analyzes and records the user's emotional state during selection in real time using an emotion engine that analyzes facial expressions, voice, and input text. For example, if the user smiles while selecting "Education," it will be recorded as a positive emotion. The input is the user's facial expressions, voice, and input text, and the output is the recorded emotional information.

[0682] Step 7:

[0683] The server vectorizes the keywords selected by the user. In this process, if the selected keyword exists in a specific position on the list, it sets that position to 1 and sets other positions to 0. For example, if "education" and "economy" are selected, the corresponding vector will be "[1, 1, 0, 0, ...]". The input is the keyword selected by the user, and the output is the vectorized keyword.

[0684] Step 8:

[0685] The server calculates the cosine similarity between the user vector and each candidate's keyword vector. It then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. The inputs are the user vector, each candidate's vector, and the emotion information, and the output is the calculated weighted cosine similarity.

[0686] Step 9:

[0687] The server sorts each candidate in descending order of similarity based on the calculated weighted similarity. This information is displayed to the user through the terminal. For example, if the user is interested in "education" and "economy," the candidates who best match those interests and emotional state are displayed at the top. The input is the calculated weighted similarity, and the output is a list of candidates sorted in descending order of similarity.

[0688] (Application example 2)

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

[0690] In Internet shopping and electronic payments, it is difficult for users to find the best products and services based on their own interests. In particular, recommendation systems that ignore users' emotional information cannot provide products that truly meet their needs. Furthermore, users may become overwhelmed by the large amount of information available, making it difficult for them to make appropriate decisions. This poses a challenge in terms of improving user satisfaction and stimulating purchasing motivation.

[0691] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for saving keyword vectors linked to each candidate in a database, means for randomly presenting the saved keywords, means for vectorizing keywords selected by the user, means for analyzing the user's emotional information in real time, means for calculating the similarity between the user vector and the candidate vector and evaluating the weighted similarity that reflects the emotional information, and means for displaying candidates based on the similarity. This makes it possible to recommend optimal products and services that take into account the user's emotional state as well as their interests and concerns.

[0692] An "election bulletin" is a document containing campaign promises and policies announced by an election candidate.

[0693] "Keywords" are important words or phrases extracted from text data.

[0694] "Vectorization" is the process of converting text data into numerical vectors.

[0695] A "database" is a system for storing and managing data in an organized manner.

[0696] "Random presentation" means that saved keywords are randomly selected and displayed.

[0697] "User" refers to a person who uses the system.

[0698] "Emotion information" is data that indicates the emotional state that the user experiences during selection or operation.

[0699] "Real-time analysis" refers to the process of analyzing data immediately without delay.

[0700] "Similarity" is a value that indicates the similarity between two vectors.

[0701] "Weighted similarity" is a similarity that is adjusted taking into account emotional information.

[0702] "Recommend" means suggesting the best options to the user.

[0703] As an embodiment of the present invention, a system is provided that recommends optimal products and services to a user while taking into consideration emotional information of the user. This system is configured as follows.

[0704] System Configuration

[0705] 1. Server

[0706] The server collects product and service descriptions and stores them in text format, such as "Innovative Devices and Software for Education" or "Latest Economic News and Market Analysis."

[0707] 2. Keyword extraction and vectorization

[0708] The server preprocesses the collected text data, lowercasing it and removing punctuation as necessary. It then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and represent them as numerical vectors. For example, the Python library scikit-learn can be used for this process.

[0709] 3. Saving Vector Data

[0710] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each product. The database can be MySQL, MongoDB, or similar.

[0711] 4. Keyword Randomization

[0712] The server aggregates all product keywords into a single list and randomly shuffles this list, allowing the user to choose unbiased from the presented keyword list.

[0713] 5. User-selected keywords

[0714] The device presents a shuffled keyword list to the user, who then selects several keywords from the list based on their own interests. The device can be a smartphone or tablet.

[0715] 6. Emotion Recognition by Emotion Engine

[0716] The device is equipped with an emotion engine that analyzes the user's facial expressions, voice, and input text. This allows it to recognize the user's emotional state in real time when selecting keywords. This information is recorded for later processing. The emotion engine can be EmotionEngine (a virtual library).

[0717] 7. Vectorize your selected keywords

[0718] The server runs a process to vectorize the keywords selected by the user. If the selected keyword is in a specific position on the list, it sets that position to 1, and all other positions to 0. This process can also be done using scikit-learn.

[0719] 8. Similarity calculation

[0720] The server calculates the cosine similarity between the user vector and each product's keyword vector. It then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. This weighted similarity takes into account the influence of the user's emotional state on keyword selection.

[0721] 9. Product Display

[0722] The server sorts products and services in descending order of similarity based on the calculated weighted similarity. This allows it to create a list of products and services that are most suitable for the user. The device displays products and services to the user in descending order of similarity. For example, if the user is interested in "education" and "economy," the device will display products and services that best match those interests and emotional state at the top. The user can make their purchasing decisions based on this list.

[0723] Specific examples

[0724] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[0725] 1. The user selects "education" and "economy" from a random list of keywords presented to them through their terminal.

[0726] 2. The device analyzes the user's selected emotion (e.g., joy or excitement) using an emotion engine and records the information.

[0727] 3. The server creates a user vector based on these keywords and emotion information.

[0728] 4. The server calculates the weighted cosine similarity between the user vector and the keyword vector of the product or service, and finds the product or service that is closest to the user.

[0729] 5. The server displays products and services in order of similarity. For example, if educational devices or economic news analysis have the highest similarity, they will be displayed at the top.

[0730] Specific input prompt examples:

[0731] "The user expressed interest in 'education' and 'economy' while browsing the page. The emotion engine detected joy. Use this to recommend products."

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

[0733] Step 1: Collect election bulletins (product description data)

[0734] The server collects the description data for each product and stores it in text format. During this process, the server retrieves data from various databases and websites on the Internet. The input is the product description data itself, and the output is the stored text data.

[0735] Step 2: Keyword extraction and vectorization

[0736] The server preprocesses the collected text data, lowercasing it and removing punctuation as needed. Then, it uses TF-IDF to extract important keywords from the text and express them as a numerical vector. The input is the preprocessed text data, and the output is a keyword vector.

[0737] Step 3: Save the vector data

[0738] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each product. The input is the keyword vector, and the output is the vector data stored in the database.

[0739] Step 4: Randomize Keywords

[0740] The server collects all product keywords into a single list and randomly shuffles this list. Shuffling allows the user to choose from the presented keyword list without bias. The input is the stored keyword list, and the output is the randomly shuffled keyword list.

[0741] Step 5: User-selected keywords

[0742] The terminal presents a shuffled list of keywords to the user. The user selects some keywords from the presented list based on their own interests. The input is the randomized keyword list, and the output is the keywords selected by the user.

[0743] Step 6: Emotion Recognition with the Emotion Engine

[0744] The device uses an emotion engine that analyzes the user's facial expressions, voice, and input text to recognize the user's emotional state in real time when selecting keywords. This information is recorded for later processing. The input is emotional information such as the user's voice, facial expressions, and text, and the output is analyzed emotional data.

[0745] Step 7: Vectorize your chosen keywords

[0746] The server runs a process to vectorize the user-selected keywords. If the selected keyword is in a particular position on the list, it sets that position to 1, and all other positions to 0. The input is the user-selected keyword, and the output is the user vector.

[0747] Step 8: Similarity calculation

[0748] The server calculates the cosine similarity between the user vector and the keyword vector of the product. It then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. This weighted similarity takes into account the impact of the user's emotional state on keyword selection. The inputs are the user vector, product vector, and emotion data, and the output is the weighted similarity.

[0749] Step 9: Display your products

[0750] The server sorts products and services in descending order of similarity based on the calculated weighted similarity, and the terminal displays the products and services to the user in descending order of similarity. The input is the weighted similarity and product data, and the output is a product list presented to the user.

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

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

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

[0754] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0767] As an embodiment of the present invention, a system is provided that extracts keywords from election bulletins and allows voters to select candidates based on their own interests. This system is configured as follows.

[0768] 1. Collection of election bulletins

[0769] The server collects the election bulletins of each candidate and stores their campaign promises and policy details in text format. For example, Candidate A's campaign promises include "improving education and increasing housing support."

[0770] 2. Keyword extraction and vectorization

[0771] The server preprocesses the collected text data, converting it to lowercase and removing punctuation as necessary. It then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and convert them into numerical vectors. This allows the importance of each keyword to be expressed as a number.

[0772] 3. Saving Vector Data

[0773] The server stores the generated keyword vectors in a database, which allows the policies and pledges of each candidate to be managed as numerical data.

[0774] 4. Keyword Randomization

[0775] The server compiles all candidate keywords into a single list and randomly shuffles it. Randomization allows users to choose keywords without any fixed bias.

[0776] 5. User-selected keywords

[0777] The user uses the terminal to select keywords that interest them from the presented keyword list, for example, "education" and "economy."

[0778] 6. Vectorize the selected keywords

[0779] The server runs a process to vectorize the keywords selected by the user, using the simple method of setting a 1 in positions where the selected keyword occurs and a 0 in other positions.

[0780] 7. Similarity calculation

[0781] The server calculates the similarity between the user vector and each candidate's keyword vector. It uses cosine similarity to measure the similarity between each vector as a number. This similarity calculation evaluates which candidate is closest to the user's chosen keywords.

[0782] 8. Display of Candidates

[0783] The server sorts the candidates based on the calculated similarity. Finally, the list is displayed to the user in order of the candidates who are closest to the user's own beliefs. For example, if the user has a strong interest in "education" and "economy," candidates who match these interests will be displayed first.

[0784] Specific examples

[0785] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[0786] Through the terminal, the user selects "education" and "economy" from a random list of keywords presented to them.

[0787] The server creates a user vector based on these keywords.

[0788] The server calculates the cosine similarity between the user vector and the candidate's keyword vector to find the candidate that is closest to the user.

[0789] The server displays candidates in descending order of similarity, and for example, if candidate A has the highest similarity, candidate A will be displayed at the top.

[0790] The system allows users to easily find the most suitable candidates based on their interests, facilitating voting decisions, allowing voters to cast their votes based on policy content, promoting a transparent and fair election process.

[0791] The processing flow will be explained below.

[0792] Step 1:

[0793] The server collects election bulletins and stores the contents of each candidate's policies and pledges in text format. For example, the pledges of "Candidate A" include "improving education and increasing housing support."

[0794] Step 2:

[0795] The server formats and preprocesses the collected text data, specifically lowercasing the text and removing punctuation and special characters.

[0796] Step 3:

[0797] The server applies TF-IDF (Term Frequency-Inverse Document Frequency) to the preprocessed text data to extract keywords from each election bulletin. The extracted keywords are expressed as numerical vectors.

[0798] Step 4:

[0799] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each candidate.

[0800] Step 5:

[0801] The server compiles all candidate keywords into a single list and randomly shuffles this list, allowing voters to choose unbiased from the presented keyword list.

[0802] Step 6:

[0803] The terminal presents the shuffled keyword list to the user, who then selects some keywords from the list based on his or her own interests.

[0804] Step 7:

[0805] The server creates a user vector based on the keywords selected by the user. For example, if the selected keyword is in a specific position on the list, it sets that position to 1, and all other positions to 0.

[0806] Step 8:

[0807] The server calculates the cosine similarity between the created user vector and each candidate keyword vector stored in the database. Using the cosine similarity, the angle between the user vector and the candidate vector is measured and the similarity is evaluated as a numerical value.

[0808] Step 9:

[0809] The server sorts the candidates based on the calculated cosine similarity, allowing it to list the candidates most suitable for the user.

[0810] Step 10:

[0811] The device will display candidates to the user in order of similarity. For example, if the user is interested in "education" and "economy," the candidate who best matches those interests will be displayed at the top. The user can then decide who to vote for based on this list.

[0812] Example 1

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

[0814] Conventional election information systems make it difficult for voters to obtain detailed information about candidates' pledges and policies in a centralized manner and select the appropriate candidate based on their own interests. Furthermore, there was a lack of improved accuracy in keyword extraction and vectorization, as well as automated data collection methods, which could potentially compromise the transparency and fairness of election information. There was a need to provide a system that would solve these issues and enable voters to select candidates efficiently and fairly.

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

[0816] In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for storing keyword vectors associated with each candidate in a database, means for randomly presenting the stored keywords, means for vectorizing keywords selected by a user, means for calculating the similarity between a user vector and a candidate vector, means for displaying candidates based on the similarity, means for automating the collection of election bulletin data, means for randomly displaying keywords selected by a user, and means for preprocessing keyword data by lowercasing and removing punctuation. This enables voters to efficiently select candidates based on their interests, improving the transparency and fairness of election information.

[0817] An "election bulletin" is an official document published by each candidate in an election to communicate their campaign promises and policies to voters.

[0818] "Keyword extraction methods" are techniques and algorithms used to extract important words and phrases from election bulletins.

[0819] "Vectorization" is the process of converting keywords or text data into numerical vectors, making them computable.

[0820] "Means for storing in a database" refers to a technology or system for efficiently storing the generated keyword vectors so that they can be easily searched and accessed later.

[0821] A "random presentation method" is a technique or algorithm for randomly rearranging keywords and presenting them to the user without relying on a specific order.

[0822] The "means for vectorizing user-selected keywords" is a process for converting user-selected keywords into numerical vectors, making them comparable with other data.

[0823] The "means for calculating similarity" refers to a technique or algorithm for numerically indicating the similarity between a user vector and a candidate vector and for making an evaluation based on that numerical value.

[0824] The "means for displaying candidates" refers to a technology or system for sorting candidates based on the calculated similarity and visually presenting them to the user.

[0825] "Means for automating the collection of election bulletin data" refers to web scraping and data mining technologies for efficiently and automatically collecting election bulletin data.

[0826] "Means for lowercasing and removing punctuation marks as preprocessing of keyword data" refers to techniques and processes for lowercasing and removing unnecessary punctuation marks to make text data easier to analyze.

[0827] This invention provides a system that extracts keywords from election bulletins and allows voters to select candidates based on their interests. This system consists of three main components: a server, a terminal, and a user.

[0828] The server first collects election bulletin data. Specifically, it uses web scraping technology (for example, Python's BeautifulSoup library) to obtain election bulletins from the official website of the Election Commission and each candidate's website, and saves them in text format. The saved text data is then preprocessed using natural language processing libraries such as NLTK and spaCy. Preprocessing includes lowercasing and removing punctuation.

[0829] Next, the server extracts important keywords from the preprocessed text data using TF-IDF and converts them into numerical vectors using the scikit-learn library. This vector data is then stored in a database (e.g., MySQL or PostgreSQL).

[0830] The server then combines all candidate keyword lists into a single list and randomly shuffles it using Python's random library, ready to be presented to the user.

[0831] Users select keywords that interest them from a random keyword list presented to them using their device (PC or smartphone). The selected keywords are then vectorized by the server using one-hot encoding technology.

[0832] Next, the server calculates the cosine similarity between the keyword vector selected by the user and the keyword vector of each candidate, again using the scikit-learn library. Based on the calculated similarity, the candidates are sorted in order of their proximity to the user's interests.

[0833] Finally, the server displays the results of the similarity calculation to the user via their terminal, and the user can select the most suitable candidate based on the presented information.

[0834] As a specific example, consider the case where a user is interested in "education" and "economy."

[0835] 1. The server collects and preprocesses election bulletin data.

[0836] 2. The server extracts important keywords and vectorizes them. In this case, for example, "education" and "economy" are extracted.

[0837] 3. The server randomly shuffles all candidate keywords and presents them to the user.

[0838] 4. The user selects "education" and "economy" from the presented keyword list.

[0839] 5. The server creates a user vector based on the user's selection and calculates the similarity with each candidate's vector using cosine similarity.

[0840] 6. The server sorts the candidates based on similarity and displays them to the user via their device. The user then makes a voting decision based on the displayed list of candidates.

[0841] This system allows users to select candidates efficiently and fairly.

[0842] Prompt example

[0843] "Please extract policy keywords related to education and the economy from the latest election bulletins and recommend candidates based on those."

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

[0845] System program processing flow

[0846] Step 1: Collect election information

[0847] The server periodically collects election bulletin data from the official website of the Election Commission and each candidate's website. Specifically, it uses Python's BeautifulSoup library to scrape web pages and obtains candidates' campaign promises and policy details in text format.

[0848] Input: URL of the web page where the election bulletin is published

[0849] Output: Candidate pledge data in text format

[0850] Specific operation: HTML parsing and text extraction using BeautifulSoup

[0851] Step 2: Keyword extraction and preprocessing

[0852] The server preprocesses the collected text data by using Python's NLTK and spaCy to lowercase the text and remove punctuation and special characters, and then uses the TF-IDF method to extract important keywords.

[0853] Input: Candidate pledge data in text format

[0854] Output: Preprocessed text data and important keywords

[0855] Specific operation: Preprocessing using NLTK and spaCy (lowercasing, punctuation removal), keyword extraction using TF-IDF

[0856] Step 3: Vectorize keywords

[0857] The server vectorizes the keywords extracted from the preprocessed text data using the scikit-learn library. Based on the TF-IDF score, the importance of each keyword is expressed as a numerical vector.

[0858] Input: Preprocessed text data and important keywords

[0859] Output: TF-IDF based keyword vectors

[0860] Specific operation: TF-IDF score calculation and vectorization

[0861] Step 4: Save the vector data

[0862] The server stores the generated keyword vectors in a database (e.g., MySQL or PostgreSQL). A keyword vector is saved for each candidate, allowing for easy searching and access later.

[0863] Input: TF-IDF based keyword vectors

[0864] Output: Keyword vectors stored in a database

[0865] Specific operation: Write operation to database

[0866] Step 5: Randomize Keywords

[0867] The server compiles all candidate keyword lists into a single list and randomly shuffles them using Python's random library, which is then presented to the user.

[0868] Input: Keyword vectors stored in a database

[0869] Output: Randomly shuffled keyword list

[0870] Specific operation: Shuffling using the Random library

[0871] Step 6: User-selected keywords

[0872] Users use their devices (PCs or smartphones) to select keywords that interest them from a randomly arranged keyword list by clicking or tapping on the screen.

[0873] Input: Randomly shuffled keyword list

[0874] Output: User selected keywords

[0875] Specific action: Keyword selection through the user interface

[0876] Step 7: Vectorize your chosen keywords

[0877] The server vectorizes the keywords selected by the user using one-hot encoding, which sets 1 to the vector position corresponding to the selected keyword and 0 to the other positions.

[0878] Input: User-selected keywords

[0879] Output: User vectors by one-hot encoding

[0880] Specific operation: Vectorization of user keywords (one-hot encoding)

[0881] Step 8: Similarity calculation

[0882] The server calculates the similarity between the user vector and each candidate's keyword vector, using the cosine_similarity function from the scikit-learn library.

[0883] Input: User vectors obtained by one-hot encoding, candidate keyword vectors stored in the database

[0884] Output: Cosine similarity with each candidate

[0885] Specific operation: Calculating cosine similarity (cosine_similarity in scikit-learn)

[0886] Step 9: View candidates

[0887] The server sorts the candidates based on the calculated similarity and displays them on the user's device in order of the most similar. The user then makes a voting decision based on the information presented.

[0888] Input: Cosine similarity with each candidate

[0889] Output: A list of candidates based on similarity

[0890] Specific behavior: Displaying a list of candidates through a user interface

[0891] Prompt example

[0892] "Please extract policy keywords related to education and the economy from the latest election bulletins and recommend candidates based on those."

[0893] (Application example 1)

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

[0895] Current food delivery systems provide a wide range of menus and restaurant information, but it is difficult for users to select the most suitable dishes and dining establishments based on their interests. In addition, when users search for menus or restaurants based on specific keywords, bias is likely to occur, making it difficult to obtain truly personalized suggestions.

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

[0897] In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for storing keyword vectors associated with each candidate in a database, means for randomly presenting the stored keywords, means for vectorizing keywords selected by the user, means for calculating the similarity between the user vector and the candidate vector, means for displaying candidates based on the similarity, means for collecting information on food menus and dining establishments, extracting and vectorizing keywords from menu descriptions, and means for recommending food menus and dining establishments based on the keywords selected by the user, thereby enabling users to receive personalized meal suggestions based on their interests.

[0898] An "election bulletin" is an official document in which a candidate outlines his or her policies and positions during the election campaign.

[0899] "Keywords" are words or phrases that summarize and highlight a particular context or piece of information.

[0900] "Vectorization" is the process of converting non-numeric information, such as text data, into numerical vectors, making them analyzable.

[0901] A "database" is a system for efficiently storing, managing, and searching structured data.

[0902] "Random presentation" means presenting information randomly, without any particular order or regularity.

[0903] "Similarity" is a measure of the relative closeness or relatedness between two objects.

[0904] A "food menu" is a list of the foods and drinks served at a food establishment.

[0905] "Food and beverage establishment" means a facility for serving food and beverages.

[0906] "Extraction" is the process of selecting specific information or elements from the original data set.

[0907] "TF-IDF" stands for Term Frequency-Inverse Document Frequency and is a statistical method for measuring the importance of words in a document.

[0908] "Cosine similarity" is a method for measuring the similarity between two vectors using the angle between them.

[0909] The present invention is a food delivery system that allows users to find the most suitable food menu and dining establishment based on their interests. A specific example of the system is described below.

[0910] 1. Data Collection:

[0911] The server collects information about food menus and restaurants, including menu names, descriptions, prices, and types of food. This data is saved as a data file in CSV format or similar.

[0912] 2. Keyword extraction and vectorization:

[0913] The server preprocesses the collected text data, converting it to lowercase and removing punctuation. It then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and convert them into numerical vectors. This process uses the Python libraries scikit-learn and Pandas.

[0914] 3. Random keyword suggestions:

[0915] The server creates a list of extracted keywords, randomly shuffles it, and presents it to the user, allowing the user to choose keywords without any fixed bias.

[0916] 4. User-selected keywords:

[0917] The user uses the terminal to select keywords of interest from a presented keyword list, for example, "spicy" and "sushi."

[0918] 5. User keyword vectorization:

[0919] The server vectorizes the keywords selected by the user, setting 1 to the positions where the selected keyword appears and 0 to the other positions.

[0920] 6. Similarity calculation:

[0921] The server calculates the similarity between the user vector and the keyword vector of each dish using cosine similarity, and evaluates the menus and restaurants that are closest to the keywords selected by the user.

[0922] 7. Display of recommendation results:

[0923] The server then lists menus and restaurants in descending order of similarity based on the calculated similarity and displays them to the user. For example, if a user has a high interest in "spicy" and "sushi," menus that match these will be displayed preferentially.

[0924] Hardware and software used

[0925] Hardware: Smartphone

[0926] Software: Python, Pandas, scikit-learn

[0927] Specific examples

[0928] As a concrete example, consider a user opening a food delivery app and selecting "spicy" and "sushi" from a randomly displayed list of keywords. At this step, the prompt text might look like this:

[0929] "Enter keywords for the food you want to choose: (e.g. 'sushi', 'spicy', etc.)"

[0930] The server vectorizes the selected keywords and calculates the cosine similarity to prioritize menu items such as spicy California rolls and spicy tuna rolls. This system allows users to receive personalized meal suggestions based on their interests, providing a more intuitive and satisfying food delivery experience.

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

[0932] Step 1:

[0933] The server collects information about food menus and dining establishments. This step uses a CSV format data file to obtain information such as menu name, description, price, and type of food. The input is food menu information from an external data source, and the output is structured data stored in a database.

[0934] Step 2:

[0935] The server preprocesses the collected text data, converting it to lowercase and removing punctuation. Next, it uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and convert them into a numerical vector. The input is the preprocessed text data, and the output is a numerical vector of keywords. Specifically, it uses Python's Pandas and scikit-learn libraries.

[0936] Step 3:

[0937] The server creates a list of extracted keywords, randomly shuffles it, and presents it to the user. In this step, each keyword in the list is rearranged in a random order. The input is a list of keywords, and the output is a randomized list of keywords.

[0938] Step 4:

[0939] A user uses a terminal to select keywords of interest from a presented keyword list. For example, they can choose "spicy" and "sushi." The input is a randomized keyword list, and the output is a user-selected keyword list.

[0940] Step 5:

[0941] The server vectorizes the keywords selected by the user. In this process, it sets the position of the selected keyword to 1 and other positions to 0. The input is the list of keywords selected by the user, and the output is a numeric vector of the user keywords.

[0942] Step 6:

[0943] The server calculates the similarity between the user vector and the keyword vector of each dish using cosine similarity. In this case, it compares the user vector with the menu vector and measures the angle between each vector. The input is the user vector and the keyword vector of each dish, and the output is a similarity score.

[0944] Step 7:

[0945] The server displays menus and restaurants to the user in descending order of similarity based on the calculated similarity. Specifically, the menus that are closest to the keywords selected by the user are listed at the top. The input is the similarity score, and the output is a list of recommended food menus and restaurants.

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

[0947] As an embodiment of the present invention, a system is provided that extracts keywords from election bulletins and recommends candidates based on the keywords and emotional information selected by voters. This system is configured as follows.

[0948] System Configuration

[0949] 1. Collection of election bulletins

[0950] The server collects the election bulletins of each candidate and stores their campaign promises and policy details in text format. For example, Candidate A's campaign promises include "improving education and increasing housing support."

[0951] 2. Keyword extraction and vectorization

[0952] The server preprocesses the collected text data, lowercasing it and removing punctuation as necessary, then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and represent them as numerical vectors.

[0953] 3. Saving Vector Data

[0954] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each candidate.

[0955] 4. Keyword Randomization

[0956] The server compiles all candidate keywords into a single list and randomly shuffles this list, allowing the user to choose unbiased from the presented keyword list.

[0957] 5. User-selected keywords

[0958] The terminal presents the shuffled keyword list to the user, who then selects some keywords from the list based on his or her own interests.

[0959] 6. Emotion Recognition by Emotion Engine

[0960] The device is equipped with an emotion engine that analyzes the user's facial expressions, voice, and input text, allowing it to recognize the user's emotional state in real time as they select keywords. This information is recorded for later processing.

[0961] 7. Vectorize your selected keywords

[0962] The server runs a process to vectorize the keywords selected by the user: if the selected keyword is in a particular position on the list, it sets that position to 1, and everywhere else it sets it to 0.

[0963] 8. Similarity calculation

[0964] The server calculates the cosine similarity between the user vector and each candidate keyword vector, and then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. This weighted similarity takes into account the influence of the user's emotional state on keyword selection.

[0965] 9. Display of Candidates

[0966] The server sorts the candidates based on the calculated weighted similarity, thereby listing the candidates that are most suitable for the user.

[0967] The device will display candidates to the user in order of similarity. For example, if the user is interested in "education" and "economy," the candidate who best matches those interests and emotional state will be displayed at the top. The user can then decide who to vote for based on this list.

[0968] Specific examples

[0969] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[0970] 1. The user selects "education" and "economy" from a random list of keywords presented to them through their terminal.

[0971] 2. The device analyzes the user's selected emotion (e.g., joy or excitement) using an emotion engine and records the information.

[0972] 3. The server creates a user vector based on these keywords and emotion information.

[0973] 4. The server calculates the weighted cosine similarity between the user vector and the candidate keyword vectors to find the candidate that is closest to the user.

[0974] 5. The server displays candidates in descending order of similarity. For example, if candidate A has the highest similarity, candidate A will be displayed at the top.

[0975] This system allows users to easily find the most suitable candidate based on their interests and emotional state, facilitating voting decisions. Voters can cast their votes based on policy content and their own emotions, promoting a transparent and fair election process.

[0976] The processing flow will be explained below.

[0977] Step 1:

[0978] The server collects election bulletins and stores the contents of each candidate's policies and pledges in text format. For example, the pledge of "Candidate A" is "Improve education and increase housing support."

[0979] Step 2:

[0980] The server formats and preprocesses the collected text data, specifically lowercasing the text and removing punctuation and special characters.

[0981] Step 3:

[0982] The server applies TF-IDF (Term Frequency-Inverse Document Frequency) to the preprocessed text data to extract keywords from each election bulletin. The extracted keywords are expressed as numerical vectors.

[0983] Step 4:

[0984] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each candidate.

[0985] Step 5:

[0986] The server compiles all candidate keywords into a single list and randomly shuffles this list, allowing the user to choose unbiased from the presented keyword list.

[0987] Step 6:

[0988] The terminal presents the shuffled keyword list to the user, who then selects some keywords from the list based on his or her own interests.

[0989] Step 7:

[0990] The device uses an emotion engine that analyzes the user's facial expressions, voice, and input text during keyword selection to recognize the user's emotional state in real time, and this emotional information is recorded for later processing.

[0991] Step 8:

[0992] The server creates a user vector based on the keywords selected by the user. If the selected keyword is in a specific position on the list, it sets that position to 1, and all other positions to 0.

[0993] Step 9:

[0994] The server uses the emotion information and user vector sent from the device to create a weighted user vector that reflects the user's emotional state. This weighted user vector takes into account the influence of the user's emotional state on keyword selection.

[0995] Step 10:

[0996] The server calculates the cosine similarity between the weighted user vector and each candidate keyword vector stored in the database. The cosine similarity is used to measure the angle between the weighted user vector and the candidate vector, and evaluates the similarity as a numerical value.

[0997] Step 11:

[0998] The server sorts the candidates based on the calculated cosine similarity, allowing it to list the candidates most suitable for the user.

[0999] Step 12:

[1000] The device will display candidates to the user in order of similarity. For example, if the user is interested in "education" and "economy," the candidate who best matches those interests and emotional state will be displayed at the top. The user can then decide who to vote for based on this list.

[1001] Example 2

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

[1003] Conventional election support systems have difficulty reflecting the emotional state of voters when selecting candidates based on their own interests. Furthermore, bias is likely to occur in keyword extraction and presentation, making it difficult to ensure fairness in candidate selection. Therefore, there is a growing need for a candidate recommendation system that is fair and reflects emotional states.

[1004] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for saving keyword vectors linked to each candidate in a database, means for randomly presenting the saved keywords, means for vectorizing keywords selected by the user, means for calculating the similarity between the user vector and the candidate vector, means for analyzing and recording the user's emotional state in real time, and means for displaying candidates based on the similarity. This enables voters to fairly select the most suitable candidate based on their interests and emotional state.

[1005] An "election bulletin" is an official document used by each candidate to inform voters of their campaign promises and policies during an election.

[1006] "Keywords" are important words or phrases in election bulletins that indicate the key points of a candidate's campaign promises or policies.

[1007] A "vector" is a format in which a keyword is quantified and expressed as a point in a multidimensional space.

[1008] A "database" is a system that efficiently stores large amounts of information and enables it to be searched and updated.

[1009] "User" refers to the voters who use this system.

[1010] The "similarity" is a numerical value indicating the degree of match between the keyword vector selected by the user and the keyword vector of the candidate.

[1011] "Emotional state" refers to the psychological response of a user when selecting a keyword.

[1012] "Real-time analysis" means processing data and providing results instantly while a user's actions or inputs are occurring.

[1013] As an embodiment of the present invention, we provide a system that extracts keywords from election bulletins and recommends candidates based on the keywords selected by voters and their emotional information. This system functions mainly through the collaboration of three entities: a server, a terminal, and a user.

[1014] The server collects the election bulletins of each candidate and stores their campaign promises and policies in a database in text format. The data is obtained from reliable sources, such as online news sites and the candidate's official website. This data is stored in a structured format for later processing.

[1015] Next, the server preprocesses the collected text data, extracting keywords using TF-IDF (Term Frequency-Inverse Document Frequency) and vectorizing them as numerical vectors. This allows each candidate's campaign promises and policy content to be expressed numerically and made available for calculation. During this process, preprocessing such as lowercasing the text data and removing punctuation marks is performed.

[1016] The server stores the generated keyword vectors in a dedicated database, allowing the keyword vectors for each candidate to be managed in a unified format. The stored data can be used effectively because it quantifies the candidate's characteristics and campaign promises.

[1017] The server then combines all candidate keywords into a single list and randomly shuffles this list, allowing users to fairly choose from the presented keyword list. The shuffled keyword list is then presented to the user via their terminal.

[1018] Users select keywords based on their interests from a shuffled keyword list presented via their device. For example, if a user is interested in "education" and "economy," they select these keywords.

[1019] The terminal is equipped with an emotion engine that analyzes the user's emotional state (e.g., joy or excitement) in real time during selection. This emotion engine analyzes the user's facial expressions, voice, and input text and records the information. This information is used later in the candidate recommendation process.

[1020] The server creates a vector of the keywords selected by the user. In this process, if the selected keyword is in a specific position on the list, it sets that position to 1, and sets other positions to 0. For example, if "education" and "economy" are selected, the corresponding vector will be "[1, 1, 0, 0, ...]".

[1021] The server calculates the cosine similarity between the user vector and each candidate's keyword vector, and then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine, thereby taking into account the impact of the user's emotions on the selection results.

[1022] Finally, the server sorts the candidates based on the calculated weighted similarity. This information is displayed to the user via their device. The user can then decide who to vote for based on this list. For example, if a user is interested in "education" and "economy," the candidates that best match their interests and emotional state will be displayed at the top.

[1023] Specific examples

[1024] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[1025] 1. The user selects "education" and "economy" from a random keyword list presented through the terminal.

[1026] 2. The device analyzes the user's selected emotion (e.g., joy or excitement) using an emotion engine and records the information.

[1027] 3. The server creates a user vector based on these keywords and emotion information. For example, if "education" and "economy" are selected and positive emotion is high, the vector will be "[1, 1, 0, ...]".

[1028] 4. The server calculates the weighted cosine similarity between the user vector and the candidate keyword vector, and finds the candidate who is closest to the user. For example, candidate A with a high similarity is displayed as a number such as "0.85", and candidate B as "0.78".

[1029] 5. The server sorts the candidates in descending order of similarity. For example, if candidate A has the highest similarity, candidate A will be displayed at the top. The terminal displays this to the user, who can then decide who to vote for based on this ordered list.

[1030] The system allows users to easily find the best candidate based on their interests, concerns and emotional state, making voting decisions easier.

[1031] Example prompts for generative AI models

[1032] "The keywords I'm interested in are 'education' and 'economy.' Based on these, please explain a candidate recommendation system that includes emotional information."

[1033] "Please tell me in detail the process flow of a specific system that uses user-selected keywords and emotional state to recommend candidates."

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

[1035] Step 1:

[1036] The server automatically collects each candidate's election bulletin from the Internet and other reliable sources. The collected data is stored in a database in text format. For example, Candidate A's campaign promise "Improve education and increase housing support" is saved as a text file. The input is the election bulletin data from the Internet, and the output is the text data stored in the database.

[1037] Step 2:

[1038] The server preprocesses the stored text data. During this process, the text is converted to lowercase and punctuation and unnecessary whitespace are removed. Next, the TF-IDF algorithm is used to extract important keywords and vectorize them into numerical vectors. For example, if "education" appears frequently and is important, it will be given a high score. The input is the stored text data, and the output is the vectorized keywords.

[1039] Step 3:

[1040] The server stores the generated keyword vectors in a database. This allows the keyword vectors for each candidate to be managed in a unified format. The stored data is used for subsequent processing, as it quantifies and stores the candidate's characteristics and campaign promises. The input is the vectorized keywords, and the output is the keyword vector stored in the database.

[1041] Step 4:

[1042] The server compiles all candidate keywords into a single list and randomly shuffles this list. This allows users to fairly choose from the presented keyword list. The shuffled keyword list is sent to the terminal and displayed. The input is the keywords of all candidates retrieved from the database, and the output is a randomly shuffled keyword list.

[1043] Step 5:

[1044] The terminal presents the shuffled keyword list to the user. The user selects keywords based on their own interests. For example, if the user is interested in "education" and "economy," they select those keywords. The input is the shuffled keyword list, and the output is the keywords selected by the user.

[1045] Step 6:

[1046] The device analyzes and records the user's emotional state during selection in real time using an emotion engine that analyzes facial expressions, voice, and input text. For example, if the user smiles while selecting "Education," it will be recorded as a positive emotion. The input is the user's facial expressions, voice, and input text, and the output is the recorded emotional information.

[1047] Step 7:

[1048] The server vectorizes the keywords selected by the user. In this process, if the selected keyword exists in a specific position on the list, it sets that position to 1 and sets other positions to 0. For example, if "education" and "economy" are selected, the corresponding vector will be "[1, 1, 0, 0, ...]". The input is the keyword selected by the user, and the output is the vectorized keyword.

[1049] Step 8:

[1050] The server calculates the cosine similarity between the user vector and each candidate's keyword vector. It then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. The inputs are the user vector, each candidate's vector, and the emotion information, and the output is the calculated weighted cosine similarity.

[1051] Step 9:

[1052] The server sorts each candidate in descending order of similarity based on the calculated weighted similarity. This information is displayed to the user through the terminal. For example, if the user is interested in "education" and "economy," the candidates who best match those interests and emotional state are displayed at the top. The input is the calculated weighted similarity, and the output is a list of candidates sorted in descending order of similarity.

[1053] (Application example 2)

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

[1055] In Internet shopping and electronic payments, it is difficult for users to find the best products and services based on their own interests. In particular, recommendation systems that ignore users' emotional information cannot provide products that truly meet their needs. Furthermore, users may become overwhelmed by the large amount of information available, making it difficult for them to make appropriate decisions. This poses a challenge in terms of improving user satisfaction and stimulating purchasing motivation.

[1056] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for saving keyword vectors linked to each candidate in a database, means for randomly presenting the saved keywords, means for vectorizing keywords selected by the user, means for analyzing the user's emotional information in real time, means for calculating the similarity between the user vector and the candidate vector and evaluating the weighted similarity that reflects the emotional information, and means for displaying candidates based on the similarity. This makes it possible to recommend optimal products and services that take into account the user's emotional state as well as their interests and concerns.

[1057] An "election bulletin" is a document containing campaign promises and policies announced by an election candidate.

[1058] "Keywords" are important words or phrases extracted from text data.

[1059] "Vectorization" is the process of converting text data into numerical vectors.

[1060] A "database" is a system for storing and managing data in an organized manner.

[1061] "Random presentation" means that saved keywords are randomly selected and displayed.

[1062] "User" refers to a person who uses the system.

[1063] "Emotion information" is data that indicates the emotional state that the user experiences during selection or operation.

[1064] "Real-time analysis" refers to the process of analyzing data immediately without delay.

[1065] "Similarity" is a value that indicates the similarity between two vectors.

[1066] "Weighted similarity" is a similarity that is adjusted taking into account emotional information.

[1067] "Recommend" means suggesting the best options to the user.

[1068] As an embodiment of the present invention, a system is provided that recommends optimal products and services to a user while taking into consideration emotional information of the user. This system is configured as follows.

[1069] System Configuration

[1070] 1. Server

[1071] The server collects product and service descriptions and stores them in text format, such as "Innovative Devices and Software for Education" or "Latest Economic News and Market Analysis."

[1072] 2. Keyword extraction and vectorization

[1073] The server preprocesses the collected text data, lowercasing it and removing punctuation as necessary. It then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and represent them as numerical vectors. For example, the Python library scikit-learn can be used for this process.

[1074] 3. Saving Vector Data

[1075] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each product. The database can be MySQL, MongoDB, or similar.

[1076] 4. Keyword Randomization

[1077] The server aggregates all product keywords into a single list and randomly shuffles this list, allowing the user to choose unbiased from the presented keyword list.

[1078] 5. User-selected keywords

[1079] The device presents a shuffled keyword list to the user, who then selects several keywords from the list based on their own interests. The device can be a smartphone or tablet.

[1080] 6. Emotion Recognition by Emotion Engine

[1081] The device is equipped with an emotion engine that analyzes the user's facial expressions, voice, and input text. This allows it to recognize the user's emotional state in real time when selecting keywords. This information is recorded for later processing. The emotion engine can be EmotionEngine (a virtual library).

[1082] 7. Vectorize your selected keywords

[1083] The server runs a process to vectorize the keywords selected by the user. If the selected keyword is in a specific position on the list, it sets that position to 1, and all other positions to 0. This process can also be done using scikit-learn.

[1084] 8. Similarity calculation

[1085] The server calculates the cosine similarity between the user vector and each product's keyword vector. It then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. This weighted similarity takes into account the influence of the user's emotional state on keyword selection.

[1086] 9. Product Display

[1087] The server sorts products and services in descending order of similarity based on the calculated weighted similarity. This allows it to create a list of products and services that are most suitable for the user. The device displays products and services to the user in descending order of similarity. For example, if the user is interested in "education" and "economy," the device will display products and services that best match those interests and emotional state at the top. The user can make their purchasing decisions based on this list.

[1088] Specific examples

[1089] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[1090] 1. The user selects "education" and "economy" from a random list of keywords presented to them through their terminal.

[1091] 2. The device analyzes the user's selected emotion (e.g., joy or excitement) using an emotion engine and records the information.

[1092] 3. The server creates a user vector based on these keywords and emotion information.

[1093] 4. The server calculates the weighted cosine similarity between the user vector and the keyword vector of the product or service, and finds the product or service that is closest to the user.

[1094] 5. The server displays products and services in order of similarity. For example, if educational devices or economic news analysis have the highest similarity, they will be displayed at the top.

[1095] Specific input prompt examples:

[1096] "The user expressed interest in 'education' and 'economy' while browsing the page. The emotion engine detected joy. Use this to recommend products."

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

[1098] Step 1: Collect election bulletins (product description data)

[1099] The server collects the description data for each product and stores it in text format. During this process, the server retrieves data from various databases and websites on the Internet. The input is the product description data itself, and the output is the stored text data.

[1100] Step 2: Keyword extraction and vectorization

[1101] The server preprocesses the collected text data, lowercasing it and removing punctuation as needed. Then, it uses TF-IDF to extract important keywords from the text and express them as a numerical vector. The input is the preprocessed text data, and the output is a keyword vector.

[1102] Step 3: Save the vector data

[1103] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each product. The input is the keyword vector, and the output is the vector data stored in the database.

[1104] Step 4: Randomize Keywords

[1105] The server collects all product keywords into a single list and randomly shuffles this list. Shuffling allows the user to choose from the presented keyword list without bias. The input is the stored keyword list, and the output is the randomly shuffled keyword list.

[1106] Step 5: User-selected keywords

[1107] The terminal presents a shuffled list of keywords to the user. The user selects some keywords from the presented list based on their own interests. The input is the randomized keyword list, and the output is the keywords selected by the user.

[1108] Step 6: Emotion Recognition with the Emotion Engine

[1109] The device uses an emotion engine that analyzes the user's facial expressions, voice, and input text to recognize the user's emotional state in real time when selecting keywords. This information is recorded for later processing. The input is emotional information such as the user's voice, facial expressions, and text, and the output is analyzed emotional data.

[1110] Step 7: Vectorize your chosen keywords

[1111] The server runs a process to vectorize the user-selected keywords. If the selected keyword is in a particular position on the list, it sets that position to 1, and all other positions to 0. The input is the user-selected keyword, and the output is the user vector.

[1112] Step 8: Similarity calculation

[1113] The server calculates the cosine similarity between the user vector and the keyword vector of the product. It then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. This weighted similarity takes into account the impact of the user's emotional state on keyword selection. The inputs are the user vector, product vector, and emotion data, and the output is the weighted similarity.

[1114] Step 9: Display your products

[1115] The server sorts products and services in descending order of similarity based on the calculated weighted similarity, and the terminal displays the products and services to the user in descending order of similarity. The input is the weighted similarity and product data, and the output is a product list presented to the user.

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

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

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

[1119] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1133] As an embodiment of the present invention, a system is provided that extracts keywords from election bulletins and allows voters to select candidates based on their own interests. This system is configured as follows.

[1134] 1. Collection of election bulletins

[1135] The server collects the election bulletins of each candidate and stores their campaign promises and policy details in text format. For example, Candidate A's campaign promises include "improving education and increasing housing support."

[1136] 2. Keyword extraction and vectorization

[1137] The server preprocesses the collected text data, converting it to lowercase and removing punctuation as necessary. It then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and convert them into numerical vectors. This allows the importance of each keyword to be expressed as a number.

[1138] 3. Saving Vector Data

[1139] The server stores the generated keyword vectors in a database, which allows the policies and pledges of each candidate to be managed as numerical data.

[1140] 4. Keyword Randomization

[1141] The server compiles all candidate keywords into a single list and randomly shuffles it. Randomization allows users to choose keywords without any fixed bias.

[1142] 5. User-selected keywords

[1143] The user uses the terminal to select keywords that interest them from the presented keyword list, for example, "education" and "economy."

[1144] 6. Vectorize the selected keywords

[1145] The server runs a process to vectorize the keywords selected by the user, using the simple method of setting a 1 in positions where the selected keyword occurs and a 0 in other positions.

[1146] 7. Similarity calculation

[1147] The server calculates the similarity between the user vector and each candidate's keyword vector. It uses cosine similarity to measure the similarity between each vector as a number. This similarity calculation evaluates which candidate is closest to the user's chosen keywords.

[1148] 8. Display of Candidates

[1149] The server sorts the candidates based on the calculated similarity. Finally, the list is displayed to the user in order of the candidates who are closest to the user's own beliefs. For example, if the user has a strong interest in "education" and "economy," candidates who match these interests will be displayed first.

[1150] Specific examples

[1151] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[1152] Through the terminal, the user selects "education" and "economy" from a random list of keywords presented to them.

[1153] The server creates a user vector based on these keywords.

[1154] The server calculates the cosine similarity between the user vector and the candidate's keyword vector to find the candidate that is closest to the user.

[1155] The server displays candidates in descending order of similarity, and for example, if candidate A has the highest similarity, candidate A will be displayed at the top.

[1156] The system allows users to easily find the most suitable candidates based on their interests, facilitating voting decisions, allowing voters to cast their votes based on policy content, promoting a transparent and fair election process.

[1157] The processing flow will be explained below.

[1158] Step 1:

[1159] The server collects election bulletins and stores the contents of each candidate's policies and pledges in text format. For example, the pledges of "Candidate A" include "improving education and increasing housing support."

[1160] Step 2:

[1161] The server formats and preprocesses the collected text data, specifically lowercasing the text and removing punctuation and special characters.

[1162] Step 3:

[1163] The server applies TF-IDF (Term Frequency-Inverse Document Frequency) to the preprocessed text data to extract keywords from each election bulletin. The extracted keywords are expressed as numerical vectors.

[1164] Step 4:

[1165] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each candidate.

[1166] Step 5:

[1167] The server compiles all candidate keywords into a single list and randomly shuffles this list, allowing voters to choose unbiased from the presented keyword list.

[1168] Step 6:

[1169] The terminal presents the shuffled keyword list to the user, who then selects some keywords from the list based on his or her own interests.

[1170] Step 7:

[1171] The server creates a user vector based on the keywords selected by the user. For example, if the selected keyword is in a specific position on the list, it sets that position to 1, and all other positions to 0.

[1172] Step 8:

[1173] The server calculates the cosine similarity between the created user vector and each candidate keyword vector stored in the database. Using the cosine similarity, the angle between the user vector and the candidate vector is measured and the similarity is evaluated as a numerical value.

[1174] Step 9:

[1175] The server sorts the candidates based on the calculated cosine similarity, allowing it to list the candidates most suitable for the user.

[1176] Step 10:

[1177] The device will display candidates to the user in order of similarity. For example, if the user is interested in "education" and "economy," the candidate who best matches those interests will be displayed at the top. The user can then decide who to vote for based on this list.

[1178] Example 1

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

[1180] Conventional election information systems make it difficult for voters to obtain detailed information about candidates' pledges and policies in a centralized manner and select the appropriate candidate based on their own interests. Furthermore, there was a lack of improved accuracy in keyword extraction and vectorization, as well as automated data collection methods, which could potentially compromise the transparency and fairness of election information. There was a need to provide a system that would solve these issues and enable voters to select candidates efficiently and fairly.

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

[1182] In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for storing keyword vectors associated with each candidate in a database, means for randomly presenting the stored keywords, means for vectorizing keywords selected by a user, means for calculating the similarity between a user vector and a candidate vector, means for displaying candidates based on the similarity, means for automating the collection of election bulletin data, means for randomly displaying keywords selected by a user, and means for preprocessing keyword data by lowercasing and removing punctuation. This enables voters to efficiently select candidates based on their interests, improving the transparency and fairness of election information.

[1183] An "election bulletin" is an official document published by each candidate in an election to communicate their campaign promises and policies to voters.

[1184] "Keyword extraction methods" are techniques and algorithms used to extract important words and phrases from election bulletins.

[1185] "Vectorization" is the process of converting keywords or text data into numerical vectors, making them computable.

[1186] "Means for storing in a database" refers to a technology or system for efficiently storing the generated keyword vectors so that they can be easily searched and accessed later.

[1187] A "random presentation method" is a technique or algorithm for randomly rearranging keywords and presenting them to the user without relying on a specific order.

[1188] The "means for vectorizing user-selected keywords" is a process for converting user-selected keywords into numerical vectors, making them comparable with other data.

[1189] The "means for calculating similarity" refers to a technique or algorithm for numerically indicating the similarity between a user vector and a candidate vector and for making an evaluation based on that numerical value.

[1190] The "means for displaying candidates" refers to a technology or system for sorting candidates based on the calculated similarity and visually presenting them to the user.

[1191] "Means for automating the collection of election bulletin data" refers to web scraping and data mining technologies for efficiently and automatically collecting election bulletin data.

[1192] "Means for lowercasing and removing punctuation marks as preprocessing of keyword data" refers to techniques and processes for lowercasing and removing unnecessary punctuation marks to make text data easier to analyze.

[1193] This invention provides a system that extracts keywords from election bulletins and allows voters to select candidates based on their interests. This system consists of three main components: a server, a terminal, and a user.

[1194] The server first collects election bulletin data. Specifically, it uses web scraping technology (for example, Python's BeautifulSoup library) to obtain election bulletins from the official website of the Election Commission and each candidate's website, and saves them in text format. The saved text data is then preprocessed using natural language processing libraries such as NLTK and spaCy. Preprocessing includes lowercasing and removing punctuation.

[1195] Next, the server extracts important keywords from the preprocessed text data using TF-IDF and converts them into numerical vectors using the scikit-learn library. This vector data is then stored in a database (e.g., MySQL or PostgreSQL).

[1196] The server then combines all candidate keyword lists into a single list and randomly shuffles it using Python's random library, ready to be presented to the user.

[1197] Users select keywords that interest them from a random keyword list presented to them using their device (PC or smartphone). The selected keywords are then vectorized by the server using one-hot encoding technology.

[1198] Next, the server calculates the cosine similarity between the keyword vector selected by the user and the keyword vector of each candidate, again using the scikit-learn library. Based on the calculated similarity, the candidates are sorted in order of their proximity to the user's interests.

[1199] Finally, the server displays the results of the similarity calculation to the user via their terminal, and the user can select the most suitable candidate based on the presented information.

[1200] As a specific example, consider the case where a user is interested in "education" and "economy."

[1201] 1. The server collects and preprocesses election bulletin data.

[1202] 2. The server extracts important keywords and vectorizes them. In this case, for example, "education" and "economy" are extracted.

[1203] 3. The server randomly shuffles all candidate keywords and presents them to the user.

[1204] 4. The user selects "education" and "economy" from the presented keyword list.

[1205] 5. The server creates a user vector based on the user's selection and calculates the similarity with each candidate's vector using cosine similarity.

[1206] 6. The server sorts the candidates based on similarity and displays them to the user via their device. The user then makes a voting decision based on the displayed list of candidates.

[1207] This system allows users to select candidates efficiently and fairly.

[1208] Prompt example

[1209] "Please extract policy keywords related to education and the economy from the latest election bulletins and recommend candidates based on those."

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

[1211] System program processing flow

[1212] Step 1: Collect election information

[1213] The server periodically collects election bulletin data from the official website of the Election Commission and each candidate's website. Specifically, it uses Python's BeautifulSoup library to scrape web pages and obtains candidates' campaign promises and policy details in text format.

[1214] Input: URL of the web page where the election bulletin is published

[1215] Output: Candidate pledge data in text format

[1216] Specific operation: HTML parsing and text extraction using BeautifulSoup

[1217] Step 2: Keyword extraction and preprocessing

[1218] The server preprocesses the collected text data by using Python's NLTK and spaCy to lowercase the text and remove punctuation and special characters, and then uses the TF-IDF method to extract important keywords.

[1219] Input: Candidate pledge data in text format

[1220] Output: Preprocessed text data and important keywords

[1221] Specific operation: Preprocessing using NLTK and spaCy (lowercasing, punctuation removal), keyword extraction using TF-IDF

[1222] Step 3: Vectorize keywords

[1223] The server vectorizes the keywords extracted from the preprocessed text data using the scikit-learn library. Based on the TF-IDF score, the importance of each keyword is expressed as a numerical vector.

[1224] Input: Preprocessed text data and important keywords

[1225] Output: TF-IDF based keyword vectors

[1226] Specific operation: TF-IDF score calculation and vectorization

[1227] Step 4: Save the vector data

[1228] The server stores the generated keyword vectors in a database (e.g., MySQL or PostgreSQL). A keyword vector is saved for each candidate, allowing for easy searching and access later.

[1229] Input: TF-IDF based keyword vectors

[1230] Output: Keyword vectors stored in a database

[1231] Specific operation: Write operation to database

[1232] Step 5: Randomize Keywords

[1233] The server compiles all candidate keyword lists into a single list and randomly shuffles them using Python's random library, which is then presented to the user.

[1234] Input: Keyword vectors stored in a database

[1235] Output: Randomly shuffled keyword list

[1236] Specific operation: Shuffling using the Random library

[1237] Step 6: User-selected keywords

[1238] Users use their devices (PCs or smartphones) to select keywords that interest them from a randomly arranged keyword list by clicking or tapping on the screen.

[1239] Input: Randomly shuffled keyword list

[1240] Output: User selected keywords

[1241] Specific action: Keyword selection through the user interface

[1242] Step 7: Vectorize your chosen keywords

[1243] The server vectorizes the keywords selected by the user using one-hot encoding, which sets 1 to the vector position corresponding to the selected keyword and 0 to the other positions.

[1244] Input: User-selected keywords

[1245] Output: User vectors by one-hot encoding

[1246] Specific operation: Vectorization of user keywords (one-hot encoding)

[1247] Step 8: Similarity calculation

[1248] The server calculates the similarity between the user vector and each candidate's keyword vector, using the cosine_similarity function from the scikit-learn library.

[1249] Input: User vectors obtained by one-hot encoding, candidate keyword vectors stored in the database

[1250] Output: Cosine similarity with each candidate

[1251] Specific operation: Calculating cosine similarity (cosine_similarity in scikit-learn)

[1252] Step 9: View candidates

[1253] The server sorts the candidates based on the calculated similarity and displays them on the user's device in order of the most similar. The user then makes a voting decision based on the information presented.

[1254] Input: Cosine similarity with each candidate

[1255] Output: A list of candidates based on similarity

[1256] Specific behavior: Displaying a list of candidates through a user interface

[1257] Prompt example

[1258] "Please extract policy keywords related to education and the economy from the latest election bulletins and recommend candidates based on those."

[1259] (Application example 1)

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

[1261] Current food delivery systems provide a wide range of menus and restaurant information, but it is difficult for users to select the most suitable dishes and dining establishments based on their interests. In addition, when users search for menus or restaurants based on specific keywords, bias is likely to occur, making it difficult to obtain truly personalized suggestions.

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

[1263] In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for storing keyword vectors associated with each candidate in a database, means for randomly presenting the stored keywords, means for vectorizing keywords selected by the user, means for calculating the similarity between the user vector and the candidate vector, means for displaying candidates based on the similarity, means for collecting information on food menus and dining establishments, extracting and vectorizing keywords from menu descriptions, and means for recommending food menus and dining establishments based on the keywords selected by the user, thereby enabling users to receive personalized meal suggestions based on their interests.

[1264] An "election bulletin" is an official document in which a candidate outlines his or her policies and positions during the election campaign.

[1265] "Keywords" are words or phrases that summarize and highlight a particular context or piece of information.

[1266] "Vectorization" is the process of converting non-numeric information, such as text data, into numerical vectors, making them analyzable.

[1267] A "database" is a system for efficiently storing, managing, and searching structured data.

[1268] "Random presentation" means presenting information randomly, without any particular order or regularity.

[1269] "Similarity" is a measure of the relative closeness or relatedness between two objects.

[1270] A "food menu" is a list of the foods and drinks served at a food establishment.

[1271] "Food and beverage establishment" means a facility for serving food and beverages.

[1272] "Extraction" is the process of selecting specific information or elements from the original data set.

[1273] "TF-IDF" stands for Term Frequency-Inverse Document Frequency and is a statistical method for measuring the importance of words in a document.

[1274] "Cosine similarity" is a method for measuring the similarity between two vectors using the angle between them.

[1275] The present invention is a food delivery system that allows users to find the most suitable food menu and dining establishment based on their interests. A specific example of the system is described below.

[1276] 1. Data Collection:

[1277] The server collects information about food menus and restaurants, including menu names, descriptions, prices, and types of food. This data is saved as a data file in CSV format or similar.

[1278] 2. Keyword extraction and vectorization:

[1279] The server preprocesses the collected text data, converting it to lowercase and removing punctuation. It then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and convert them into numerical vectors. This process uses the Python libraries scikit-learn and Pandas.

[1280] 3. Random keyword suggestions:

[1281] The server creates a list of extracted keywords, randomly shuffles it, and presents it to the user, allowing the user to choose keywords without any fixed bias.

[1282] 4. User-selected keywords:

[1283] The user uses the terminal to select keywords of interest from a presented keyword list, for example, "spicy" and "sushi."

[1284] 5. User keyword vectorization:

[1285] The server vectorizes the keywords selected by the user, setting 1 to the positions where the selected keyword appears and 0 to the other positions.

[1286] 6. Similarity calculation:

[1287] The server calculates the similarity between the user vector and the keyword vector of each dish using cosine similarity, and evaluates the menus and restaurants that are closest to the keywords selected by the user.

[1288] 7. Display of recommendation results:

[1289] The server then lists menus and restaurants in descending order of similarity based on the calculated similarity and displays them to the user. For example, if a user has a high interest in "spicy" and "sushi," menus that match these will be displayed preferentially.

[1290] Hardware and software used

[1291] Hardware: Smartphone

[1292] Software: Python, Pandas, scikit-learn

[1293] Specific examples

[1294] As a concrete example, consider a user opening a food delivery app and selecting "spicy" and "sushi" from a randomly displayed list of keywords. At this step, the prompt text might look like this:

[1295] "Enter keywords for the food you want to choose: (e.g. 'sushi', 'spicy', etc.)"

[1296] The server vectorizes the selected keywords and calculates the cosine similarity to prioritize menu items such as spicy California rolls and spicy tuna rolls. This system allows users to receive personalized meal suggestions based on their interests, providing a more intuitive and satisfying food delivery experience.

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

[1298] Step 1:

[1299] The server collects information about food menus and dining establishments. This step uses a CSV format data file to obtain information such as menu name, description, price, and type of food. The input is food menu information from an external data source, and the output is structured data stored in a database.

[1300] Step 2:

[1301] The server preprocesses the collected text data, converting it to lowercase and removing punctuation. Next, it uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and convert them into a numerical vector. The input is the preprocessed text data, and the output is a numerical vector of keywords. Specifically, it uses Python's Pandas and scikit-learn libraries.

[1302] Step 3:

[1303] The server creates a list of extracted keywords, randomly shuffles it, and presents it to the user. In this step, each keyword in the list is rearranged in a random order. The input is a list of keywords, and the output is a randomized list of keywords.

[1304] Step 4:

[1305] A user uses a terminal to select keywords of interest from a presented keyword list. For example, they can choose "spicy" and "sushi." The input is a randomized keyword list, and the output is a user-selected keyword list.

[1306] Step 5:

[1307] The server vectorizes the keywords selected by the user. In this process, it sets the position of the selected keyword to 1 and other positions to 0. The input is the list of keywords selected by the user, and the output is a numeric vector of the user keywords.

[1308] Step 6:

[1309] The server calculates the similarity between the user vector and the keyword vector of each dish using cosine similarity. In this case, it compares the user vector with the menu vector and measures the angle between each vector. The input is the user vector and the keyword vector of each dish, and the output is a similarity score.

[1310] Step 7:

[1311] The server displays menus and restaurants to the user in descending order of similarity based on the calculated similarity. Specifically, the menus that are closest to the keywords selected by the user are listed at the top. The input is the similarity score, and the output is a list of recommended food menus and restaurants.

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

[1313] As an embodiment of the present invention, a system is provided that extracts keywords from election bulletins and recommends candidates based on the keywords and emotional information selected by voters. This system is configured as follows.

[1314] System Configuration

[1315] 1. Collection of election bulletins

[1316] The server collects the election bulletins of each candidate and stores their campaign promises and policy details in text format. For example, Candidate A's campaign promises include "improving education and increasing housing support."

[1317] 2. Keyword extraction and vectorization

[1318] The server preprocesses the collected text data, lowercasing it and removing punctuation as necessary, then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and represent them as numerical vectors.

[1319] 3. Saving Vector Data

[1320] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each candidate.

[1321] 4. Keyword Randomization

[1322] The server compiles all candidate keywords into a single list and randomly shuffles this list, allowing the user to choose unbiased from the presented keyword list.

[1323] 5. User-selected keywords

[1324] The terminal presents the shuffled keyword list to the user, who then selects some keywords from the list based on his or her own interests.

[1325] 6. Emotion Recognition by Emotion Engine

[1326] The device is equipped with an emotion engine that analyzes the user's facial expressions, voice, and input text, allowing it to recognize the user's emotional state in real time as they select keywords. This information is recorded for later processing.

[1327] 7. Vectorize your selected keywords

[1328] The server runs a process to vectorize the keywords selected by the user: if the selected keyword is in a particular position on the list, it sets that position to 1, and everywhere else it sets it to 0.

[1329] 8. Similarity calculation

[1330] The server calculates the cosine similarity between the user vector and each candidate keyword vector, and then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. This weighted similarity takes into account the influence of the user's emotional state on keyword selection.

[1331] 9. Display of Candidates

[1332] The server sorts the candidates based on the calculated weighted similarity, thereby listing the candidates that are most suitable for the user.

[1333] The device will display candidates to the user in order of similarity. For example, if the user is interested in "education" and "economy," the candidate who best matches those interests and emotional state will be displayed at the top. The user can then decide who to vote for based on this list.

[1334] Specific examples

[1335] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[1336] 1. The user selects "education" and "economy" from a random list of keywords presented to them through their terminal.

[1337] 2. The device analyzes the user's selected emotion (e.g., joy or excitement) using an emotion engine and records the information.

[1338] 3. The server creates a user vector based on these keywords and emotion information.

[1339] 4. The server calculates the weighted cosine similarity between the user vector and the candidate keyword vectors to find the candidate that is closest to the user.

[1340] 5. The server displays candidates in descending order of similarity. For example, if candidate A has the highest similarity, candidate A will be displayed at the top.

[1341] This system allows users to easily find the most suitable candidate based on their interests and emotional state, facilitating voting decisions. Voters can cast their votes based on policy content and their own emotions, promoting a transparent and fair election process.

[1342] The processing flow will be explained below.

[1343] Step 1:

[1344] The server collects election bulletins and stores the contents of each candidate's policies and pledges in text format. For example, the pledge of "Candidate A" is "Improve education and increase housing support."

[1345] Step 2:

[1346] The server formats and preprocesses the collected text data, specifically lowercasing the text and removing punctuation and special characters.

[1347] Step 3:

[1348] The server applies TF-IDF (Term Frequency-Inverse Document Frequency) to the preprocessed text data to extract keywords from each election bulletin. The extracted keywords are expressed as numerical vectors.

[1349] Step 4:

[1350] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each candidate.

[1351] Step 5:

[1352] The server compiles all candidate keywords into a single list and randomly shuffles this list, allowing the user to choose unbiased from the presented keyword list.

[1353] Step 6:

[1354] The terminal presents the shuffled keyword list to the user, who then selects some keywords from the list based on his or her own interests.

[1355] Step 7:

[1356] The device uses an emotion engine that analyzes the user's facial expressions, voice, and input text during keyword selection to recognize the user's emotional state in real time, and this emotional information is recorded for later processing.

[1357] Step 8:

[1358] The server creates a user vector based on the keywords selected by the user. If the selected keyword is in a specific position on the list, it sets that position to 1, and all other positions to 0.

[1359] Step 9:

[1360] The server uses the emotion information and user vector sent from the device to create a weighted user vector that reflects the user's emotional state. This weighted user vector takes into account the influence of the user's emotional state on keyword selection.

[1361] Step 10:

[1362] The server calculates the cosine similarity between the weighted user vector and each candidate keyword vector stored in the database. The cosine similarity is used to measure the angle between the weighted user vector and the candidate vector, and evaluates the similarity as a numerical value.

[1363] Step 11:

[1364] The server sorts the candidates based on the calculated cosine similarity, allowing it to list the candidates most suitable for the user.

[1365] Step 12:

[1366] The device will display candidates to the user in order of similarity. For example, if the user is interested in "education" and "economy," the candidate who best matches those interests and emotional state will be displayed at the top. The user can then decide who to vote for based on this list.

[1367] Example 2

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

[1369] Conventional election support systems have difficulty reflecting the emotional state of voters when selecting candidates based on their own interests. Furthermore, bias is likely to occur in keyword extraction and presentation, making it difficult to ensure fairness in candidate selection. Therefore, there is a growing need for a candidate recommendation system that is fair and reflects emotional states.

[1370] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for saving keyword vectors linked to each candidate in a database, means for randomly presenting the saved keywords, means for vectorizing keywords selected by the user, means for calculating the similarity between the user vector and the candidate vector, means for analyzing and recording the user's emotional state in real time, and means for displaying candidates based on the similarity. This enables voters to fairly select the most suitable candidate based on their interests and emotional state.

[1371] An "election bulletin" is an official document used by each candidate to inform voters of their campaign promises and policies during an election.

[1372] "Keywords" are important words or phrases in election bulletins that indicate the key points of a candidate's campaign promises or policies.

[1373] A "vector" is a format in which a keyword is quantified and expressed as a point in a multidimensional space.

[1374] A "database" is a system that efficiently stores large amounts of information and enables it to be searched and updated.

[1375] "User" refers to the voters who use this system.

[1376] The "similarity" is a numerical value indicating the degree of match between the keyword vector selected by the user and the keyword vector of the candidate.

[1377] "Emotional state" refers to the psychological response of a user when selecting a keyword.

[1378] "Real-time analysis" means processing data and providing results instantly while a user's actions or inputs are occurring.

[1379] As an embodiment of the present invention, we provide a system that extracts keywords from election bulletins and recommends candidates based on the keywords selected by voters and their emotional information. This system functions mainly through the collaboration of three entities: a server, a terminal, and a user.

[1380] The server collects the election bulletins of each candidate and stores their campaign promises and policies in a database in text format. The data is obtained from reliable sources, such as online news sites and the candidate's official website. This data is stored in a structured format for later processing.

[1381] Next, the server preprocesses the collected text data, extracting keywords using TF-IDF (Term Frequency-Inverse Document Frequency) and vectorizing them as numerical vectors. This allows each candidate's campaign promises and policy content to be expressed numerically and made available for calculation. During this process, preprocessing such as lowercasing the text data and removing punctuation marks is performed.

[1382] The server stores the generated keyword vectors in a dedicated database, allowing the keyword vectors for each candidate to be managed in a unified format. The stored data can be used effectively because it quantifies the candidate's characteristics and campaign promises.

[1383] The server then combines all candidate keywords into a single list and randomly shuffles this list, allowing users to fairly choose from the presented keyword list. The shuffled keyword list is then presented to the user via their terminal.

[1384] Users select keywords based on their interests from a shuffled keyword list presented via their device. For example, if a user is interested in "education" and "economy," they select these keywords.

[1385] The terminal is equipped with an emotion engine that analyzes the user's emotional state (e.g., joy or excitement) in real time during selection. This emotion engine analyzes the user's facial expressions, voice, and input text and records the information. This information is used later in the candidate recommendation process.

[1386] The server creates a vector of the keywords selected by the user. In this process, if the selected keyword is in a specific position on the list, it sets that position to 1, and sets other positions to 0. For example, if "education" and "economy" are selected, the corresponding vector will be "[1, 1, 0, 0, ...]".

[1387] The server calculates the cosine similarity between the user vector and each candidate's keyword vector, and then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine, thereby taking into account the impact of the user's emotions on the selection results.

[1388] Finally, the server sorts the candidates based on the calculated weighted similarity. This information is displayed to the user via their device. The user can then decide who to vote for based on this list. For example, if a user is interested in "education" and "economy," the candidates that best match their interests and emotional state will be displayed at the top.

[1389] Specific examples

[1390] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[1391] 1. The user selects "education" and "economy" from a random keyword list presented through the terminal.

[1392] 2. The device analyzes the user's selected emotion (e.g., joy or excitement) using an emotion engine and records the information.

[1393] 3. The server creates a user vector based on these keywords and emotion information. For example, if "education" and "economy" are selected and positive emotion is high, the vector will be "[1, 1, 0, ...]".

[1394] 4. The server calculates the weighted cosine similarity between the user vector and the candidate keyword vector, and finds the candidate who is closest to the user. For example, candidate A with a high similarity is displayed as a number such as "0.85", and candidate B as "0.78".

[1395] 5. The server sorts the candidates in descending order of similarity. For example, if candidate A has the highest similarity, candidate A will be displayed at the top. The terminal displays this to the user, who can then decide who to vote for based on this ordered list.

[1396] The system allows users to easily find the best candidate based on their interests, concerns and emotional state, making voting decisions easier.

[1397] Example prompts for generative AI models

[1398] "The keywords I'm interested in are 'education' and 'economy.' Based on these, please explain a candidate recommendation system that includes emotional information."

[1399] "Please tell me in detail the process flow of a specific system that uses user-selected keywords and emotional state to recommend candidates."

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

[1401] Step 1:

[1402] The server automatically collects each candidate's election bulletin from the Internet and other reliable sources. The collected data is stored in a database in text format. For example, Candidate A's campaign promise "Improve education and increase housing support" is saved as a text file. The input is the election bulletin data from the Internet, and the output is the text data stored in the database.

[1403] Step 2:

[1404] The server preprocesses the stored text data. During this process, the text is converted to lowercase and punctuation and unnecessary whitespace are removed. Next, the TF-IDF algorithm is used to extract important keywords and vectorize them into numerical vectors. For example, if "education" appears frequently and is important, it will be given a high score. The input is the stored text data, and the output is the vectorized keywords.

[1405] Step 3:

[1406] The server stores the generated keyword vectors in a database. This allows the keyword vectors for each candidate to be managed in a unified format. The stored data is used for subsequent processing, as it quantifies and stores the candidate's characteristics and campaign promises. The input is the vectorized keywords, and the output is the keyword vector stored in the database.

[1407] Step 4:

[1408] The server compiles all candidate keywords into a single list and randomly shuffles this list. This allows users to fairly choose from the presented keyword list. The shuffled keyword list is sent to the terminal and displayed. The input is the keywords of all candidates retrieved from the database, and the output is a randomly shuffled keyword list.

[1409] Step 5:

[1410] The terminal presents the shuffled keyword list to the user. The user selects keywords based on their own interests. For example, if the user is interested in "education" and "economy," they select those keywords. The input is the shuffled keyword list, and the output is the keywords selected by the user.

[1411] Step 6:

[1412] The device analyzes and records the user's emotional state during selection in real time using an emotion engine that analyzes facial expressions, voice, and input text. For example, if the user smiles while selecting "Education," it will be recorded as a positive emotion. The input is the user's facial expressions, voice, and input text, and the output is the recorded emotional information.

[1413] Step 7:

[1414] The server vectorizes the keywords selected by the user. In this process, if the selected keyword exists in a specific position on the list, it sets that position to 1 and sets other positions to 0. For example, if "education" and "economy" are selected, the corresponding vector will be "[1, 1, 0, 0, ...]". The input is the keyword selected by the user, and the output is the vectorized keyword.

[1415] Step 8:

[1416] The server calculates the cosine similarity between the user vector and each candidate's keyword vector. It then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. The inputs are the user vector, each candidate's vector, and the emotion information, and the output is the calculated weighted cosine similarity.

[1417] Step 9:

[1418] The server sorts each candidate in descending order of similarity based on the calculated weighted similarity. This information is displayed to the user through the terminal. For example, if the user is interested in "education" and "economy," the candidates who best match those interests and emotional state are displayed at the top. The input is the calculated weighted similarity, and the output is a list of candidates sorted in descending order of similarity.

[1419] (Application example 2)

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

[1421] In Internet shopping and electronic payments, it is difficult for users to find the best products and services based on their own interests. In particular, recommendation systems that ignore users' emotional information cannot provide products that truly meet their needs. Furthermore, users may become overwhelmed by the large amount of information available, making it difficult for them to make appropriate decisions. This poses a challenge in terms of improving user satisfaction and stimulating purchasing motivation.

[1422] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for extracting keywords from election bulletins, means for vectorizing the extracted keywords, means for saving keyword vectors linked to each candidate in a database, means for randomly presenting the saved keywords, means for vectorizing keywords selected by the user, means for analyzing the user's emotional information in real time, means for calculating the similarity between the user vector and the candidate vector and evaluating the weighted similarity that reflects the emotional information, and means for displaying candidates based on the similarity. This makes it possible to recommend optimal products and services that take into account the user's emotional state as well as their interests and concerns.

[1423] An "election bulletin" is a document containing campaign promises and policies announced by an election candidate.

[1424] "Keywords" are important words or phrases extracted from text data.

[1425] "Vectorization" is the process of converting text data into numerical vectors.

[1426] A "database" is a system for storing and managing data in an organized manner.

[1427] "Random presentation" means that saved keywords are randomly selected and displayed.

[1428] "User" refers to a person who uses the system.

[1429] "Emotion information" is data that indicates the emotional state that the user experiences during selection or operation.

[1430] "Real-time analysis" refers to the process of analyzing data immediately without delay.

[1431] "Similarity" is a value that indicates the similarity between two vectors.

[1432] "Weighted similarity" is a similarity that is adjusted taking into account emotional information.

[1433] "Recommend" means suggesting the best options to the user.

[1434] As an embodiment of the present invention, a system is provided that recommends optimal products and services to a user while taking into consideration emotional information of the user. This system is configured as follows.

[1435] System Configuration

[1436] 1. Server

[1437] The server collects product and service descriptions and stores them in text format, such as "Innovative Devices and Software for Education" or "Latest Economic News and Market Analysis."

[1438] 2. Keyword extraction and vectorization

[1439] The server preprocesses the collected text data, lowercasing it and removing punctuation as necessary. It then uses TF-IDF (Term Frequency-Inverse Document Frequency) to extract important keywords from the text and represent them as numerical vectors. For example, the Python library scikit-learn can be used for this process.

[1440] 3. Saving Vector Data

[1441] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each product. The database can be MySQL, MongoDB, or similar.

[1442] 4. Keyword Randomization

[1443] The server aggregates all product keywords into a single list and randomly shuffles this list, allowing the user to choose unbiased from the presented keyword list.

[1444] 5. User-selected keywords

[1445] The device presents a shuffled keyword list to the user, who then selects several keywords from the list based on their own interests. The device can be a smartphone or tablet.

[1446] 6. Emotion Recognition by Emotion Engine

[1447] The device is equipped with an emotion engine that analyzes the user's facial expressions, voice, and input text. This allows it to recognize the user's emotional state in real time when selecting keywords. This information is recorded for later processing. The emotion engine can be EmotionEngine (a virtual library).

[1448] 7. Vectorize your selected keywords

[1449] The server runs a process to vectorize the keywords selected by the user. If the selected keyword is in a specific position on the list, it sets that position to 1, and all other positions to 0. This process can also be done using scikit-learn.

[1450] 8. Similarity calculation

[1451] The server calculates the cosine similarity between the user vector and each product's keyword vector. It then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. This weighted similarity takes into account the influence of the user's emotional state on keyword selection.

[1452] 9. Product Display

[1453] The server sorts products and services in descending order of similarity based on the calculated weighted similarity. This allows it to create a list of products and services that are most suitable for the user. The device displays products and services to the user in descending order of similarity. For example, if the user is interested in "education" and "economy," the device will display products and services that best match those interests and emotional state at the top. The user can make their purchasing decisions based on this list.

[1454] Specific examples

[1455] For example, a specific example where the user is interested in "education" and "economy" will be shown.

[1456] 1. The user selects "education" and "economy" from a random list of keywords presented to them through their terminal.

[1457] 2. The device analyzes the user's selected emotion (e.g., joy or excitement) using an emotion engine and records the information.

[1458] 3. The server creates a user vector based on these keywords and emotion information.

[1459] 4. The server calculates the weighted cosine similarity between the user vector and the keyword vector of the product or service, and finds the product or service that is closest to the user.

[1460] 5. The server displays products and services in order of similarity. For example, if educational devices or economic news analysis have the highest similarity, they will be displayed at the top.

[1461] Specific input prompt examples:

[1462] "The user expressed interest in 'education' and 'economy' while browsing the page. The emotion engine detected joy. Use this to recommend products."

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

[1464] Step 1: Collect election bulletins (product description data)

[1465] The server collects the description data for each product and stores it in text format. During this process, the server retrieves data from various databases and websites on the Internet. The input is the product description data itself, and the output is the stored text data.

[1466] Step 2: Keyword extraction and vectorization

[1467] The server preprocesses the collected text data, lowercasing it and removing punctuation as needed. Then, it uses TF-IDF to extract important keywords from the text and express them as a numerical vector. The input is the preprocessed text data, and the output is a keyword vector.

[1468] Step 3: Save the vector data

[1469] The server stores the generated keyword vectors in a database, which makes it possible to manage the keyword vectors for each product. The input is the keyword vector, and the output is the vector data stored in the database.

[1470] Step 4: Randomize Keywords

[1471] The server collects all product keywords into a single list and randomly shuffles this list. Shuffling allows the user to choose from the presented keyword list without bias. The input is the stored keyword list, and the output is the randomly shuffled keyword list.

[1472] Step 5: User-selected keywords

[1473] The terminal presents a shuffled list of keywords to the user. The user selects some keywords from the presented list based on their own interests. The input is the randomized keyword list, and the output is the keywords selected by the user.

[1474] Step 6: Emotion Recognition with the Emotion Engine

[1475] The device uses an emotion engine that analyzes the user's facial expressions, voice, and input text to recognize the user's emotional state in real time when selecting keywords. This information is recorded for later processing. The input is emotional information such as the user's voice, facial expressions, and text, and the output is analyzed emotional data.

[1476] Step 7: Vectorize your chosen keywords

[1477] The server runs a process to vectorize the user-selected keywords. If the selected keyword is in a particular position on the list, it sets that position to 1, and all other positions to 0. The input is the user-selected keyword, and the output is the user vector.

[1478] Step 8: Similarity calculation

[1479] The server calculates the cosine similarity between the user vector and the keyword vector of the product. It then evaluates the final similarity using a weighted similarity that reflects the user's emotional state obtained from the emotion engine. This weighted similarity takes into account the impact of the user's emotional state on keyword selection. The inputs are the user vector, product vector, and emotion data, and the output is the weighted similarity.

[1480] Step 9: Display your products

[1481] The server sorts products and services in descending order of similarity based on the calculated weighted similarity, and the terminal displays the products and services to the user in descending order of similarity. The input is the weighted similarity and product data, and the output is a product list presented to the user.

[1482] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

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

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

[1485] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1486] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1487] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1488] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1489] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1490] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1491] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1492] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1493] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1494] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1495] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1496] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1497] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1498] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1499] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1500] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1501] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1502] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1503] The following is further disclosed regarding the above embodiment.

[1504] (Claim 1)

[1505] A means for extracting keywords from election bulletins;

[1506] A means for vectorizing the extracted keywords;

[1507] a means for storing the keyword vectors associated with each candidate in a database;

[1508] a means for randomly presenting the saved keywords;

[1509] means for vectorizing user-selected keywords;

[1510] means for calculating a similarity between a user vector and a candidate vector;

[1511] The system includes a means for displaying candidates based on similarity.

[1512] (Claim 2)

[1513] The system of claim 1, wherein the keyword vector is calculated using Term Frequency-Inverse Document Frequency (TF-IDF).

[1514] (Claim 3)

[1515] The system of claim 1 , wherein the similarity between the user vector and the candidate vector is calculated using cosine similarity.

[1516] "Example 1"

[1517] (Claim 1)

[1518] A means for extracting keywords from election bulletins;

[1519] A means for vectorizing the extracted keywords;

[1520] a means for storing the keyword vectors associated with each candidate in a database;

[1521] a means for randomly presenting the saved keywords;

[1522] means for vectorizing user-selected keywords;

[1523] means for calculating a similarity between a user vector and a candidate vector;

[1524] a means for displaying candidates based on similarity;

[1525] a means for automating the collection of election bulletin data;

[1526] means for randomly displaying keywords selected by a user;

[1527] A means for preprocessing keyword data by lowercasing and removing punctuation marks;

[1528] A system including:

[1529] (Claim 2)

[1530] The system of claim 1, wherein the keyword vector is calculated using Term Frequency-Inverse Document Frequency (TF-IDF).

[1531] (Claim 3)

[1532] The system of claim 1 , wherein the similarity between the user vector and the candidate vector is calculated using cosine similarity.

[1533] "Application Example 1"

[1534] (Claim 1)

[1535] A means for extracting keywords from election bulletins;

[1536] A means for vectorizing the extracted keywords;

[1537] a means for storing the keyword vectors associated with each candidate in a database;

[1538] a means for randomly presenting the saved keywords;

[1539] means for vectorizing user-selected keywords;

[1540] means for calculating a similarity between a user vector and a candidate vector;

[1541] a means for displaying candidates based on similarity;

[1542] A method for collecting information on food menus and dining facilities, extracting keywords from menu descriptions, and vectorizing them.

[1543] means for recommending food menus and dining establishments based on user-selected keywords;

[1544] A system including:

[1545] (Claim 2)

[1546] The system of claim 1, wherein the keyword vector is calculated using Term Frequency-Inverse Document Frequency (TF-IDF).

[1547] (Claim 3)

[1548] The system of claim 1 , wherein the similarity between the user vector and the candidate vector is calculated using cosine similarity.

[1549] "Example 2: Combining Emotion Engines"

[1550] (Claim 1)

[1551] A means for extracting keywords from election bulletins;

[1552] A means for vectorizing the extracted keywords;

[1553] a means for storing the keyword vectors associated with each candidate in a database;

[1554] a means for randomly presenting the saved keywords;

[1555] means for vectorizing user-selected keywords;

[1556] means for calculating a similarity between a user vector and a candidate vector;

[1557] a means for analyzing and recording the user's emotional state in real time;

[1558] The system includes a means for displaying candidates based on similarity.

[1559] (Claim 2)

[1560] The system of claim 1, wherein the keyword vector is calculated using Term Frequency-Inverse Document Frequency (TF-IDF).

[1561] (Claim 3)

[1562] The system of claim 1 , wherein the similarity between the user vector and the candidate vector is calculated using cosine similarity.

[1563] "Application example 2 when combining emotion engines"

[1564] (Claim 1)

[1565] A means for extracting keywords from election bulletins;

[1566] A means for vectorizing the extracted keywords;

[1567] a means for storing the keyword vectors associated with each candidate in a database;

[1568] a means for randomly presenting the saved keywords;

[1569] means for vectorizing user-selected keywords;

[1570] A means for analyzing user emotional information in real time;

[1571] A means for calculating a similarity between a user vector and a candidate vector and evaluating a weighted similarity that reflects emotional information;

[1572] The system includes a means for displaying candidates based on similarity.

[1573] (Claim 2)

[1574] The system of claim 1, wherein the keyword vector is calculated using Term Frequency-Inverse Document Frequency (TF-IDF).

[1575] (Claim 3)

[1576] The system of claim 1 , wherein the similarity between the user vector and the candidate vector is calculated using cosine similarity. [Explanation of symbols]

[1577] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. A means for extracting keywords from election bulletins; A means for vectorizing the extracted keywords; a means for storing the keyword vectors associated with each candidate in a database; a means for randomly presenting the saved keywords; means for vectorizing user-selected keywords; means for calculating a similarity between a user vector and a candidate vector; The system includes a means for displaying candidates based on similarity.

2. The system of claim 1 , wherein the keyword vector is calculated using Term Frequency-Inverse Document Frequency (TF-IDF).

3. The system of claim 1 , wherein the similarity between the user vector and the candidate vector is calculated using cosine similarity.

Images