System

Abstract

A system is provided.SOLUTION: A system comprising: means for collecting political information; means for analyzing and pre-processing the collected political information; means for training a generative model using the analyzed information; means for receiving a query from a user and inputting the query into the generative model; and means for receiving and sending an answer of the generative model to the user's query.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 recent years, many citizens, including young people, have found it difficult to take an interest in politics, resulting in declining voter turnout. One of the reasons for this situation is the difficulty in understanding information about everyday political activities and discussions. Furthermore, even if people are interested in politics, it is difficult to efficiently extract the necessary information from the vast amount of information available. It is necessary to solve this problem and help citizens to take a more proactive interest in politics. [Means for solving the problem]

[0005] The present invention provides a system for providing users with political information in an easy-to-understand manner by providing a means for collecting and analyzing political information. Specifically, the present invention proposes a system including the following means.

[0006] 1. Means for collecting political information: Collecting information on public pledges and parliamentary responses from government official websites and parliamentary minutes databases.

[0007] 2. Means for analyzing and preprocessing the collected political information: The collected data is tokenized and analyzed using natural language processing techniques.

[0008] 3. Means for training a generative model using the analyzed information: The preprocessed data is used to build a generative model that is trained using natural language processing techniques.

[0009] 4. Means for receiving a query from a user and inputting it into the generative model: A means for receiving a question from a user and inputting it into the generative model.

[0010] 5. Means for receiving and transmitting the generative model's answer to the user's query: The answer output by the generative model is transmitted to the user's device.

[0011] This allows users to receive complex political information in a concise manner, thereby increasing their interest in politics.

[0012] "Political information" means government policies, parliamentary debates, pledges, changes or enactments of laws, and information relating to these.

[0013] The "collection method" is a system that automatically obtains the necessary information from the government's official website and meeting minutes database.

[0014] "Analysis means" refers to a technique for tokenizing collected information, performing preprocessing such as normalization and removal of stop words, and then analyzing the data.

[0015] "Preprocessing" is a technique for converting collected information into a format that is easy for the generative model to handle, and performing operations such as tokenization and normalization.

[0016] A "generative model" is an artificial intelligence trained using natural language processing techniques to generate appropriate answers to user queries.

[0017] "Training" is the learning process that uses collected and preprocessed data to improve the accuracy and responsiveness of a generative model.

[0018] A "query" refers to a question or information request that a user enters into a system.

[0019] An "answer" is the appropriate information or answer that a generative model generates in response to a query from a user.

[0020] A "user terminal" is a device used by a user (e.g., a smartphone or personal computer) that can access the system and input queries.

[0021] "Natural language processing technology" refers to the general set of algorithms and techniques that computers use to understand, generate, and process human language. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0030] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0043] The present invention is a system for collecting and analyzing political information and providing it to users in an easily understandable manner. A specific embodiment of this system will be described below.

[0044] System Overview

[0045] This system includes a server, a user terminal, and a generative model. The server collects and analyzes political information, and the generative model uses the collected information to generate appropriate answers to user queries. The user terminal provides an interface for users to access the system and input queries.

[0046] Server Features

[0047] Data collection

[0048] The server periodically collects political information from official government websites and parliamentary record databases. Specifically, it uses APIs and web scraping technology to obtain information on campaign promises and parliamentary responses. This collection process is achieved using libraries such as "BeautifulSoup" and "Scrapy."

[0049] Data analysis and preprocessing

[0050] The collected information is parsed and preprocessed on the server using natural language processing techniques (e.g., NLTK or spaCy) to tokenize, normalize, remove stop words, etc. The preprocessed data is then used as a training dataset for the generative model.

[0051] Training a generative model

[0052] The server uses the preprocessed data to train a generative model, which uses natural language processing techniques to learn to generate appropriate answers to user queries. During the training process, the dataset is divided into training data and validation data, and the model parameters are optimized.

[0053] Query Processing and Answer Generation

[0054] When a user submits a query, the server receives the query and inputs it into the generative model. The generative model generates a response to the query and returns the result to the server. The server then formats the response and sends it to the user's device.

[0055] User device functions

[0056] Question Interface

[0057] The user terminal provides a question interface where the user can enter a query. The user enters a question in a text box and presses the "Submit" button to send the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[0058] Communicating with the Server

[0059] When a user submits a question, the user device sends the question in JSON format to the server using an HTTP POST request. Upon receiving the response from the server, the user device parses it and displays it to the user.

[0060] User operations

[0061] Launching the app

[0062] The user launches the application on their device.

[0063] Enter a question

[0064] The user enters their question into the question interface and presses the "Submit" button. For example, they might enter, "What is the current discussion about the consumption tax increase?"

[0065] Confirm answer

[0066] The user checks the response from the server displayed on the device. For example, the response may read, "Recent discussions in the Diet about raising the consumption tax have focused on the burden on living expenses and the impact on small and medium-sized businesses."

[0067] Through the above-described embodiment, users can easily obtain political information that they are interested in. Furthermore, by using a generative model, it becomes possible to provide complex information in an easy-to-understand manner.

[0068] The processing flow will be explained below.

[0069] Step 1: The server gathers political information

[0070] The server accesses the government's official website and meeting minutes database, and collects information on public pledges and parliamentary responses using APIs and web scraping technology.

[0071] Specifically, it uses libraries such as "BeautifulSoup" and "Scrapy" to extract the necessary information from web pages.

[0072] The collected information is stored in a database.

[0073] Step 2: The server parses and preprocesses the data

[0074] The server tokenizes the collected political information and analyzes it using natural language processing (NLP) techniques.

[0075] We use NLP libraries such as "NLTK" and "spaCy" to preprocess the data by tokenizing, normalizing, and removing stop words.

[0076] The preprocessed data is prepared as a training dataset for a generative model.

[0077] Step 3: The server trains the generative model

[0078] The server uses the preprocessed data to train a generative model (e.g., GPT-4®).

[0079] In the training process, the dataset is divided into training data and validation data, and the parameters of the generative model are optimized.

[0080] Once trained, the generative model is able to generate appropriate answers to user queries.

[0081] Step 4: The server deploys the generative model

[0082] The server deploys the trained generative model as an API, making it accessible from outside.

[0083] Set up a Restful API or GraphQL API and set up an endpoint to receive queries from users.

[0084] Step 5: User enters and submits question

[0085] The terminal displays an interface for the user to enter a question.

[0086] The user enters a question of interest and presses the "Submit" button. For example, "What is the current discussion about the consumption tax increase?"

[0087] Step 6: The device sends the question to the server

[0088] When a user submits a question, the device sends the question in JSON format to the server.

[0089] Send your question to the server's API endpoint using an HTTP POST request.

[0090] Step 7: The server receives the question and inputs it into the generative model

[0091] The server inputs questions received from users into the generative model.

[0092] A generative model generates appropriate answers to questions.

[0093] Step 8: The server receives and formats the generative model's answer

[0094] The server parses the answers received from the generative model and formats them as needed for display to the user.

[0095] Step 9: The server sends the formatted response to the device

[0096] The server sends the formatted response to the user terminal.

[0097] The answer is returned to the device as an HTTP response.

[0098] Step 10: The device displays the response from the server.

[0099] The terminal parses the response received from the server and displays it in a user-friendly format.

[0100] Users can check the displayed answers and get the answer to their question. For example, they might see something like, "Recent discussions in the Diet about raising the consumption tax have focused on the cost of living and the impact on small and medium-sized businesses."

[0101] Example 1

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

[0103] Conventional systems for collecting and analyzing political information collect information infrequently, making it difficult for users to instantly obtain the latest political information. Furthermore, the collected information was not pre-processed or analyzed efficiently, resulting in low accuracy of responses to users. Furthermore, there were issues with the usability of the user interface, making it difficult to input appropriate queries.

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

[0105] In this invention, the server includes means for periodically collecting political information, means for analyzing and preprocessing the collected political information using natural language processing technology, and means for training a generative model using the analyzed information, thereby enabling users to quickly and accurately obtain the latest political information.

[0106] "Political information" refers to information related to political decision-making and policies, such as government and parliamentary pledges and parliamentary responses.

[0107] A "generative model" is an algorithm or method that is trained using natural language processing techniques to generate appropriate answers to user queries.

[0108] "Natural language processing technology" is a technology that enables computers to understand, analyze, and generate natural language that humans use on a daily basis, and involves a wide range of processing including tokenization, normalization, and removal of stop words.

[0109] A "query" is a question or inquiry that a user enters to obtain desired information.

[0110] A "user terminal" is a device that a user uses to access and operate the system, and includes smartphones, tablets, personal computers, etc.

[0111] "JSON format" is an abbreviation for JavaScript (registered trademark) Object Notation, and is a text format for structuring and expressing data.

[0112] An "HTTP POST request" is a request method that uses the Hypertext Transfer Protocol to send data to a server, and is primarily used to send form data or upload files.

[0113] "Web scraping technology" is a method for automatically extracting and collecting information from websites, and is implemented using programming languages ​​and libraries.

[0114] A "question interface" is a UI (user interface) component that provides a screen and operating environment for users to input and submit queries, and includes a text box and a submit button.

[0115] MODE FOR CARRYING OUT THE INVENTION

[0116] The present invention provides a system for collecting and analyzing political information and providing it to users in an easily understandable manner. This system includes a server, a user terminal, and a generative model. Specific embodiments of this system are described below.

[0117] Server Features

[0118] 1. Data Collection

[0119] The server periodically collects political information from official government websites and parliamentary record databases. Specifically, it uses APIs and web scraping technology to obtain information on campaign promises and parliamentary responses. This collection process is carried out using web scraping libraries such as "BeautifulSoup" and "Scrapy."

[0120] 2. Data analysis and preprocessing

[0121] The collected information is analyzed and preprocessed on the server. This analysis uses natural language processing technologies such as "NLTK" and "spaCy" to tokenize, normalize, and remove stop words from the data. For example, minutes data is broken down into sentences such as "The consumption tax increase is being discussed in the Diet in relation to the cost of living," and important keywords are extracted.

[0122] 3. Training the generative model

[0123] The server uses the preprocessed data to train a generative model. This generative model uses natural language processing techniques to learn to generate appropriate answers to user queries. The server divides the dataset into training data and validation data, trains the model, and finds optimal parameters. This process uses machine learning frameworks such as "TENSORFLOW (registered trademark)" and "PyTorch."

[0124] 4. Answer generation

[0125] When a user submits a query, the server inputs the query into the generative model. The generative model generates a response to the query and returns the result to the server. The server formats the response and sends it to the user's device. For example, if the query was "What is the current discussion about the consumption tax increase?", the model would generate a response such as "The current discussion about the consumption tax increase in the Diet has focused on the burden of living expenses and the impact on small and medium-sized businesses."

[0126] User device functions

[0127] 1. Question Interface

[0128] The user terminal provides a question interface where the user can enter a query. The user enters a question in a text box and presses the "Submit" button to send the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[0129] 2. Communication with the server

[0130] When a user submits a question, the device converts the question into JSON format and sends it to the server as an HTTP POST request using the axios library. Upon receiving the response from the server, the device parses it and displays it to the user.

[0131] User operations

[0132] 1. Launch the app

[0133] A user launches an application on their device, which can be a smartphone, tablet, personal computer, or other device.

[0134] 2. Enter your question

[0135] Users enter their questions into the question interface and press the "Submit" button. Examples of questions include "What's the latest on recent environmental policy?" or "What are the talking points regarding health care reform?"

[0136] 3. Confirm answer

[0137] The user checks the response from the server displayed on the device. For example, a response such as "The latest information on environmental policy is that the main measures currently being implemented are ____" is displayed, and the user can check the details.

[0138] Through the above-described embodiment, users can easily obtain political information that interests them. Furthermore, by using a generative model, it becomes possible to provide complex information in an easy-to-understand manner. This system allows for the prompt provision of the latest political information, improving the reliability of the information and the ease of use of the user interface.

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

[0140] System processing steps

[0141] Server Processing Steps

[0142] Step 1: Data collection

[0143] Description: The server periodically collects political information, specifically using web scraping techniques and APIs to retrieve information from official government websites and parliamentary record databases.

[0144] Input: Official government website URL, API endpoint

[0145] Output: Political information (campaign promises, parliamentary responses, etc.)

[0146] What it does: It uses BeautifulSoup to parse information from websites and Scrapy to crawl web pages.

[0147] Step 2: Data analysis and preprocessing

[0148] Description: Analyzes and pre-processes collected political information, using natural language processing techniques like NLTK and spaCy to tokenize, normalize, and remove stop words from the data.

[0149] Input: Collected political information (text data)

[0150] Output: Preprocessed text data (tokenized, normalized, and stopword-removed)

[0151] Specific operation: The server uses "spaCy" to tokenize sentences and remove unnecessary words. For example, minutes data is converted into the format "The consumption tax increase is being discussed in the Diet in relation to the burden of living expenses."

[0152] Step 3: Training the generative model

[0153] Description: Train a generative model using preprocessed data. Split the dataset into training and validation data and optimize the model parameters.

[0154] Input: Preprocessed text data

[0155] Output: A trained generative model

[0156] How it works: The server trains the model using the TensorFlow or PyTorch framework, splitting the dataset into 80% for training and 20% for validation.

[0157] Step 4: Answer Generation

[0158] Description: When a user submits a query, the server inputs the query into the generative model and sends the answer generated by the model to the user's device.

[0159] Input: User query

[0160] Output: The answer from the generative model

[0161] How it works: The server receives a user query, inputs it into the model, and generates a response. For example, in response to the query "What has the recent discussion been about regarding the consumption tax increase?", the server generates the answer "The recent discussion about the consumption tax increase in the Diet has focused on the burden of living expenses and the impact on small and medium-sized businesses."

[0162] ---

[0163] User terminal processing steps

[0164] Step 5: Displaying the Question Interface

[0165] Description: The user terminal provides a question interface where the user can enter a query. The user enters the question here and presses the submit button.

[0166] Input: User Interface

[0167] Output: User query

[0168] Specific behavior: The interface is built using "HTML / CSS" and "React Native" and displays a text box and a submit button.

[0169] Step 6: Submit a query

[0170] Description: When a user enters a question and presses the submit button, the user's device converts the question into JSON format and sends an HTTP POST request to the server.

[0171] Input: User query

[0172] Output: Query data in JSON format

[0173] What it does: Uses the "axios" library to send JSON data containing the query to the server.

[0174] Step 7: Communicating with the Server

[0175] Description: The user terminal receives the response from the server, parses it and displays it in the user interface.

[0176] Input: JSON format response data from the server

[0177] Output: The response that is displayed to the user

[0178] Specific behavior: Receives JSON-formatted response data, parses it, and displays it to the user in an appropriate format.

[0179] ---

[0180] User operations

[0181] Step 8: Launch the app

[0182] Description: A user launches an application on their device.

[0183] Input: None

[0184] Output: Application home screen

[0185] Specific behavior: The user taps the app icon on the smartphone's home screen, or opens a web browser and accesses the specified URL.

[0186] Step 9: Enter your question

[0187] Description: The user enters their question into the question interface and presses the "Submit" button.

[0188] Input: User question (prompt)

[0189] Output: Query data sent to the server

[0190] What it does: Type "What's the latest on recent environmental policy?" or "Please explain the talking points on healthcare reform" into the text box and tap the send button.

[0191] Step 10: Check your answers

[0192] Description: The user checks the server's response displayed on the terminal.

[0193] Input: Response data from the server

[0194] Output: The response displayed in the user interface

[0195] Specific operation: The screen will display something like "As the latest information on environmental policy, the main measures currently being implemented are ____," and the user will confirm the details.

[0196] Through the above processing steps, the system can provide political information to users efficiently and quickly.

[0197] (Application example 1)

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

[0199] In modern online shopping site operations, policy changes and legal amendments can directly affect how products are handled and distributed. Therefore, it is necessary to quickly obtain the latest policy information and respond appropriately. However, conventional methods require a great deal of effort to collect and analyze policy information, which often results in delayed responses. There is a need for a method that solves this problem and allows online shopping site operators to efficiently respond to policy and legal amendments.

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

[0201] In this invention, the server includes means for collecting political information, means for analyzing and preprocessing the collected political information, means for training a generative model using the analyzed information, means for receiving queries from users and inputting them into the generative model, means for receiving and transmitting answers from the generative model to the user queries, means for supporting the operator of an online shopping site to respond quickly to policy changes and legal amendments, and a smartphone application that provides policy information in response to questions from users based on the above means, thereby enabling the operator of an online shopping site to efficiently respond to policy changes and legal amendments.

[0202] "Political information" is a concept that includes information related to policies and laws provided by the government or parliament.

[0203] "Analysis" refers to the process of breaking down collected data into an understandable format and processing it.

[0204] "Preprocessing" refers to a series of operations performed to prepare data for easier analysis.

[0205] A "generative model" refers to an algorithm or system that is trained to generate relevant answers to user queries.

[0206] "Query" refers to a question or request that a user enters into a system to obtain information.

[0207] "Answer" refers to the information or content that the system provides in response to a user's query.

[0208] "Smartphone application" refers to software that runs on a smartphone and is an application developed to provide specific functions or services.

[0209] "Policy change" refers to the modification of existing policies or the introduction of new policies by the government or parliament.

[0210] "Legal amendment" refers to the revision of existing laws and regulations, adding or amending new provisions or rules.

[0211] "Online shopping site operator" refers to an individual or company that manages and operates a website that sells products and services over the Internet.

[0212] The present invention is a system that uses a server, a user terminal, and a generative model to collect and analyze political information and provide it to users in an easy-to-understand manner. Specific embodiments of this system are described below.

[0213] System Overview

[0214] This system consists of a server that collects political information from official government and parliamentary websites and analyzes and preprocesses the data, a generative model that accepts queries from users and provides answers, and a user terminal with an interface for users to input queries.

[0215] Server Features

[0216] Data collection

[0217] The server periodically collects political information. To do this, it uses APIs and web scraping technology to obtain data from official government websites and meeting minutes databases. Specific methods include using libraries such as "BeautifulSoup" and "Scrapy."

[0218] Data analysis and preprocessing

[0219] The collected political information is analyzed and preprocessed on the server using natural language processing technologies such as spaCy and NLTK, which tokenize, normalize, and remove stop words from the data, making it suitable for training.

[0220] Training a generative model

[0221] The server uses the preprocessed data to train a generative model, which is designed to generate appropriate answers to user queries using artificial intelligence techniques. The training process uses a large dataset and optimizes the model by dividing the dataset into training and validation.

[0222] Query Processing and Answer Generation

[0223] When a user sends a query to the server, the server inputs the query into the generative model, which generates an appropriate answer for the question and returns the result to the server, which formats the answer and sends it to the user's device.

[0224] User device functions

[0225] Question Interface

[0226] The user terminal provides a question interface where the user can enter a query. Specifically, by entering a question in a text box and pressing the "Submit" button, the query is sent to the server. This is done using technologies such as "HTML / CSS" and "React Native."

[0227] Communicating with the Server

[0228] When a user submits a query, the user device sends the query in JSON format to the server using an HTTP POST request. After receiving a response from the server, the user device parses the response and displays it to the user.

[0229] Specific examples

[0230] For example, a user might enter a question into a smartphone application, such as "Please tell me about the new import regulations." The server receives this query and inputs it into a generative model. The generative model generates an appropriate answer based on the collected political information and returns it to the server. The server formats the answer and sends it to the user's device. The user's device displays this answer, and the user can obtain information such as, "Regarding recent import regulations, new tariff rates have been set to protect domestic producers. Specifically, standards for food additives and cosmetics have been tightened, which has resulted in an increase in inspection procedures."

[0231] Example prompt sentence:

[0232] "Please tell me about the new import regulations."

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

[0234] Step 1: Data collection

[0235] The server periodically collects political information. Specifically, it uses APIs and web scraping technology to obtain campaign promises and parliamentary responses from official government websites and meeting minutes databases. Libraries such as "BeautifulSoup" and "Scrapy" are used for this process. The input is the website URL or API endpoint, and the output is the text data of the obtained political information.

[0236] Step 2: Data analysis and preprocessing

[0237] The collected text data is analyzed and preprocessed on the server. Specifically, natural language processing techniques are used to tokenize, normalize, and remove stop words from the data. For this purpose, "spaCy" and "NLTK" are used. The input is text data, and the output is preprocessed token data.

[0238] Step 3: Training the generative model

[0239] The server uses the preprocessed token data to train a generative model. This generative model is designed to generate appropriate answers to user queries. A natural language generation model such as GPT-2 is used to train the generative model. The input is the preprocessed token data, and the output is the trained model.

[0240] Step 4: Receiving a user query

[0241] A user accesses a smartphone application, inputs a query into the question interface, for example, "Please tell me about the new import regulations," and presses the submit button. The input is the user's query, and the output is the query data sent to the server.

[0242] Step 5: Query processing and answer generation

[0243] When the server receives a query from a user, it inputs the query into the generative model, which generates an appropriate answer based on the query and returns the result to the server. The input is the user's query, and the output is the generated answer data.

[0244] Step 6: Format and submit your response

[0245] The server formats the answer returned by the generative model into an easy-to-understand format, and then sends the answer to the user's device. The input is the generated answer data, and the output is the formatted answer.

[0246] Step 7: Display the answer to the user

[0247] The user terminal receives the formatted answer sent from the server and displays it to the user. The user can check the answer displayed on the terminal and obtain the necessary information. The input is the formatted answer from the server, and the output is the information displayed on the user's display.

[0248] Example prompt sentence:

[0249] "Please tell me about the new import regulations."

[0250] The above is an explanation of each processing step of this system and its specific operation.

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

[0252] The present invention is a system that collects and analyzes political information, provides it to users in an easy-to-understand manner, and combines it with an emotion engine that recognizes the user's emotions. Specific embodiments of this system are described below.

[0253] System Overview

[0254] This system includes a server, a user terminal, a generative model, and an emotion engine. The server collects and analyzes political information, and the generative model uses the collected information to generate appropriate answers to user queries. The emotion engine recognizes the emotion of the user when entering a query and adjusts the content of the answer accordingly. The user terminal provides an interface for users to access the system and enter queries.

[0255] Server Features

[0256] Data collection

[0257] The server periodically collects political information from official government websites and parliamentary record databases. Specifically, it uses APIs and web scraping technology to obtain information on campaign promises and parliamentary responses. This collection process is achieved using libraries such as "BeautifulSoup" and "Scrapy." The collected information is then stored in a database.

[0258] Data analysis and preprocessing

[0259] The collected information is parsed and preprocessed on the server using natural language processing techniques (e.g., NLTK or spaCy) to tokenize, normalize, remove stop words, etc. The preprocessed data is then prepared as a training dataset for the generative model.

[0260] Training a generative model

[0261] The server uses the preprocessed data to train a generative model. The generative model uses natural language processing techniques to learn to generate appropriate answers to user queries. During the training process, the dataset is divided into training data and validation data, and the model parameters are optimized. After training is complete, the generative model is able to generate appropriate answers to user queries.

[0262] Query Processing and Answer Generation

[0263] When a user submits a query, the server receives the query and inputs it into the generative model. The emotion engine simultaneously analyzes the user's emotion when submitting the query and provides that information to the generative model. The generative model generates a response based on the query and emotion information and returns the result to the server. The server then formats the response and sends it to the user's device.

[0264] Emotion Engine Functions

[0265] Emotion analysis

[0266] The emotion engine analyzes the emotions expressed when a user enters a query. Analysis methods include emotion recognition from text input, emotion recognition from voice input, and even emotion recognition by analyzing the user's facial image. Using technologies such as "Emotion Recognition API" and "Facial Expression Recognition API," the engine can analyze user emotions with high accuracy.

[0267] User device functions

[0268] Question Interface

[0269] The user terminal provides a question interface where the user can enter a query. The user enters a question in a text box and presses the "Submit" button to send the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[0270] Communicating with the Server

[0271] When a user submits a question, the user device sends the question in JSON format to the server using an HTTP POST request. Upon receiving the response from the server, the user device parses it and displays it to the user.

[0272] User operations

[0273] Launching the app

[0274] The user launches the application on their device.

[0275] Enter a question

[0276] The user enters their question into the question interface and presses the "Submit" button. For example, they might enter, "What is the current discussion about the consumption tax increase?"

[0277] Confirm answer

[0278] The user checks the response from the server displayed on the device. For example, it might say, "Recent discussions in the Diet about the consumption tax increase have focused on the burden on living expenses and the impact on small and medium-sized businesses." The emotion engine also analyzes the user's emotions and adjusts the response accordingly, allowing the user to obtain information in a format that is easier to understand.

[0279] Through the above-described embodiment, users can easily obtain political information that interests them, and the information can be provided in an appropriate format through sentiment analysis. By combining a generative model and a sentiment engine, it is possible to improve the quality of responses to users and enhance the user experience.

[0280] The processing flow will be explained below.

[0281] Step 1: The server gathers political information

[0282] The server accesses the government's official website and meeting minutes database, and collects information on public pledges and parliamentary responses using APIs and web scraping technology.

[0283] Specifically, it uses libraries such as "BeautifulSoup" and "Scrapy" to extract the necessary information from web pages.

[0284] The collected information is stored in a database.

[0285] Step 2: The server parses and preprocesses the data

[0286] The server tokenizes the collected political information and analyzes it using natural language processing (NLP) techniques.

[0287] We use NLP libraries such as "NLTK" and "spaCy" to preprocess the data by tokenizing, normalizing, and removing stop words.

[0288] The preprocessed data is prepared as a training dataset for a generative model.

[0289] Step 3: The server trains the generative model

[0290] The server uses the preprocessed data to train a generative model (e.g., GPT-4).

[0291] In the training process, the dataset is divided into training data and validation data, and the parameters of the generative model are optimized.

[0292] Once trained, the generative model is able to generate appropriate answers to user queries.

[0293] Step 4: The server deploys the generative model

[0294] The server deploys the trained generative model as an API, making it accessible from outside.

[0295] Set up a Restful API or GraphQL API and set up an endpoint to receive queries from users.

[0296] Step 5: User enters and submits question

[0297] The terminal displays an interface for the user to enter a question.

[0298] The user enters a question of interest and presses the "Submit" button. For example, "What is the current discussion about the consumption tax increase?"

[0299] Step 6: The device sends the question to the server

[0300] When a user submits a question, the device sends the question in JSON format to the server.

[0301] Send your question to the server's API endpoint using an HTTP POST request.

[0302] Step 7: The server receives the question and inputs it into the emotion engine

[0303] The server inputs the question received from the user into the emotion engine.

[0304] The emotion engine analyzes the question content and the context of the user's input to recognize their emotional state.

[0305] Step 8: The emotion engine provides emotion information to the generative model

[0306] The emotion engine provides the recognized emotion information to the generative model.

[0307] The generative model generates answers with appropriate tone and content based on emotional information.

[0308] Step 9: The server receives and formats the generative model's answer

[0309] The server parses the answers received from the generative model and formats them as needed for display to the user.

[0310] Step 10: The server sends the formatted response to the device

[0311] The server sends the formatted response to the user terminal.

[0312] The answer is returned to the device as an HTTP response.

[0313] Step 11: The device displays the response from the server.

[0314] The terminal parses the response received from the server and displays it in a user-friendly format.

[0315] Users can check the displayed answers and get answers to their questions. For example, they might see something like, "Recent discussions in the Diet about the consumption tax increase have focused on the cost of living and the impact on small and medium-sized businesses." Furthermore, the emotion engine provides information in a tone that reflects the user's emotions, making it easier for users to understand.

[0316] Example 2

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

[0318] Conventional political information gathering systems have had difficulty efficiently collecting, analyzing, and providing information of interest to users in an easy-to-understand format. Furthermore, they were unable to generate appropriate responses that took the user's emotions into account, resulting in a poor user experience. It is necessary to solve this problem.

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

[0320] In this invention, the server includes means for collecting political information, means for analyzing and preprocessing the political information, means for training a data model using the analyzed information, means for receiving queries from users and inputting them into the data model, means for analyzing the user's emotions, and means for transmitting answers generated by adding the emotional information, thereby enabling users to efficiently collect and understand political information and receive responses that take their emotions into consideration.

[0321] "Political information" refers to official document information relating to the government or parliament and the content of parliamentary debates.

[0322] "Analysis" refers to the process of breaking down collected political information and understanding its meaning and structure.

[0323] "Preprocessing" refers to the process of formatting the parsed information into a format that can be used by the data model.

[0324] A "data model" is a model trained using natural language processing techniques to generate appropriate responses based on user queries.

[0325] "Query" refers to a question or request that a user enters into a system to obtain information about their concern.

[0326] "Sentiment analysis" refers to the technology of identifying the sentiment contained in a user's query or input and tailoring responses based on that sentiment.

[0327] "Sending a response" refers to the process of providing the answer generated by the generative model to the user terminal and displaying it to the user.

[0328] The present invention is a system that collects and analyzes political information, provides it to users in an easy-to-understand manner, and combines it with an emotion engine that recognizes the user's emotions. Specific embodiments of this system are described below.

[0329] Server Features

[0330] Data collection

[0331] The server collects political information from official government websites and meeting minutes databases. Specifically, it obtains the information using APIs and web scraping techniques. This processing is achieved using libraries such as "BeautifulSoup" and "Scrapy." The collected information is then stored in a database.

[0332] Data analysis and preprocessing

[0333] The server analyzes and preprocesses the collected information using natural language processing techniques such as NLTK and spaCy. The analysis process includes tokenization, normalization, and stop word removal. The preprocessed data is then prepared as a training dataset for the generative model.

[0334] Training a generative model

[0335] The server uses the preprocessed data to train a generative model. Natural language processing techniques such as Transformer and BERT are used for the generative model. During the training process, the dataset is divided into training data and validation data, and the model parameters are optimized. After training is complete, the generative model is able to generate appropriate answers to user queries.

[0336] Emotion Engine Functions

[0337] Emotion analysis

[0338] The emotion engine analyzes the emotions expressed when a user enters a query. This can be done by recognizing emotions from text input, voice input, or even by analyzing facial images. Using the "Emotion Recognition API" and "Facial Expression Recognition API," it analyzes user emotions with high accuracy.

[0339] User device functions

[0340] Question Interface

[0341] The user terminal provides a question interface where users can enter queries. This interface is built using technologies such as "HTML / CSS" and "React Native." Users can enter a question in the text box and press the "Submit" button to send the query to the server.

[0342] Communicating with the Server

[0343] When a user submits a question, the device sends it to the server in JSON format using an HTTP POST request. Upon receiving a response from the server, the device parses the information and displays it to the user.

[0344] User operations

[0345] A user launches the application on their device and enters "What has been discussed recently about the consumption tax increase?" into the question interface. When the user presses the "Send" button, the query is sent to the server. The server inputs this query into a generative model, and an emotion engine analyzes the user's emotions. The generative model then generates a response based on the query and emotion information and returns it to the server. The server formats the response and sends it to the user's device, where the user can view it. For example, the response may appear as "Recent discussions about the consumption tax increase in the Diet have focused on the burden of living costs and the impact on small and medium-sized businesses."

[0346] Through this system, users can efficiently collect and analyze political information they are interested in and obtain it in an appropriate format. By combining a generative model with an emotion engine, it is possible to improve the quality of responses to users and enhance the user experience.

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

[0348] Step 1:

[0349] The server accesses the government's official website and the minutes database and collects information using APIs and web scraping technology. It uses libraries such as "BeautifulSoup" and "Scrapy" to analyze web pages and obtain information on campaign promises and parliamentary responses. The input is the government's official website and the minutes database, and the output is a dataset of collected political information.

[0350] Step 2:

[0351] The server stores the collected political information in a database. Specifically, it formats the information into an appropriate format and stores it in the database. This database uses "MySQL (registered trademark)" or "PostgreSQL." The input is the collected political information, and the output is the data stored in the database.

[0352] Step 3:

[0353] The server retrieves the collected data from the database and performs natural language processing using NLTK and spaCy. Here, the data is tokenized, normalized, and stop words are removed. The input is political information retrieved from the database, and the output is the preprocessed data.

[0354] Step 4:

[0355] The server uses the preprocessed data as a training dataset for a generative model. It trains the data model using natural language processing techniques such as Transformer and BERT. During the training process, the dataset is split into training data and validation data, and the model parameters are optimized. The input is the preprocessed data, and the output is a trained generative model.

[0356] Step 5:

[0357] A user starts the application on their device and inputs a query into the question interface. For example, they input, "What is the current discussion about the consumption tax increase?" The input is the query from the user, and the output is the transmission of the query by the device.

[0358] Step 6:

[0359] The terminal converts the query entered by the user into JSON format and sends it to the server via an HTTP POST request. The input is the query from the user, and the output is the request sent to the server.

[0360] Step 7:

[0361] The server receives a user query and inputs the received query into the generative model. The input is the query sent from the terminal, and the output is the query input to the generative model.

[0362] Step 8:

[0363] The emotion engine analyzes the emotion of the user when they enter a query. This is done using text analysis or speech analysis. For example, it uses the Emotion Recognition API or Facial Expression Recognition API. The input is the user's query, and the output is the analyzed emotion information.

[0364] Step 9:

[0365] Based on the emotion information provided by the emotion engine, the generative model generates a response to the query. The input is the query and emotion information, and the output is the response result. For example, the generated response might be, "Recent discussions in the Diet about the consumption tax increase have focused on the burden of living expenses and the impact on small and medium-sized businesses."

[0366] Step 10:

[0367] The server formats the response results obtained from the generative model. It formats the results into an appropriate format and sends them to the user's device. The input is the response results from the generative model, and the output is the response formatted for sending to the device.

[0368] Step 11:

[0369] The device receives the response from the server, parses it from JSON format, and displays it in a user-friendly format based on that information. The input is the formatted response, and the output is the response that is displayed to the user. For example, it might say, "Recent discussions in the Diet about raising the consumption tax have focused on the cost of living and the impact on small and medium-sized businesses."

[0370] (Application example 2)

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

[0372] In today's information society, it is important to quickly and accurately collect political and product information and provide it to users in an easy-to-understand manner. However, conventional systems have difficulty analyzing user emotions and adjusting responses accordingly, resulting in a poor user experience. Furthermore, in brick-and-mortar stores, there is a similar lack of support that reflects user emotions, making it difficult to improve customer satisfaction.

[0373] The identification processing 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 collecting political information, means for analyzing and preprocessing the collected political information, means for training a generative model using the analyzed information, means for receiving a query from a user and inputting it into the generative model, means for receiving and sending the generative model's response to the user's query, means for analyzing the user's emotion at the time of query input, means for adjusting the generated response based on the emotion analysis result, means for collecting and analyzing product information in a physical store, means for receiving a user's query regarding product information in the physical store and providing an answer, and means for adjusting customer service based on the emotion analysis result. This makes it possible to provide responses that reflect the user's emotion and adjust customer service in a physical store in real time.

[0374] "Political information" refers to data related to public policies, such as campaign promises and parliamentary responses provided by the government and parliament.

[0375] A "generative model" is an algorithm that is trained using natural language processing techniques to generate appropriate answers to user queries.

[0376] "Sentiment analysis" is the process of identifying emotions from a user's text or voice input.

[0377] A "query" is a question or request that a user enters into a system.

[0378] A "brick and mortar store" is a commercial establishment that exists in a physical location and offers goods and services.

[0379] The "emotion engine" is a system component that analyzes the user's emotions and adjusts responses accordingly.

[0380] "Product information" refers to data about the features and specifications of products sold in physical stores.

[0381] A "user terminal" is an electronic device used by a user to access the system and enter queries.

[0382] "Data collection" refers to the process of obtaining necessary information from official government websites, meeting minutes databases, etc.

[0383] "Natural language processing technology" is an artificial intelligence technology for understanding and processing human language.

[0384] An "HTTP POST request" is one of the communication protocols for sending data to a web server.

[0385] "Analysis" is the process of processing and formatting collected data.

[0386] "Preprocessing" refers to operations such as tokenizing, normalizing, and removing stop words from data prior to data analysis.

[0387] A "generated answer" is a response provided by a generative model to a user's query.

[0388] A "training dataset" is a collection of data used to train a generative model.

[0389] This invention is a system that collects and analyzes political and product information, recognizes user emotions, and adjusts responses. This system includes a server, a user terminal, a generative model, and an emotion engine.

[0390] Server Features

[0391] 1. Data collection: The server periodically collects political information from official government websites and parliamentary record databases. Using APIs and web scraping technology, it retrieves information on campaign promises and parliamentary responses and stores the information in a database. Specifically, it uses libraries such as "BeautifulSoup" and "Scrapy."

[0392] 2. Data analysis and preprocessing: The collected information is parsed and preprocessed on the server. Natural language processing techniques (e.g., spaCy or NLTK) are used to tokenize, normalize, and remove stop words from the data. The preprocessed data is then prepared as a training dataset for the generative model.

[0393] 3. Training the generative model: The server uses the preprocessed data to train the generative model, which uses natural language processing techniques to learn to generate appropriate answers to user queries.

[0394] 4. Query processing and answer generation: When a user submits a query, the server receives the query and inputs it into the generative model. At the same time, the emotion engine analyzes the user's emotion when submitting the query and provides that information to the generative model. The generative model generates a response based on the query and emotion information and returns the result to the server. The server then formats the response and sends it to the user's device.

[0395] Emotion Engine Functions

[0396] 1. Emotion Analysis: The emotion engine analyzes the emotions expressed when a user enters a query. It recognizes emotions from text input, voice input, and even by analyzing the user's facial image. Specific technologies used include the "Emotion Recognition API" and "Facial Expression Recognition API."

[0397] User device functions

[0398] 1. Question interface: The user device provides an interface where the user can enter a query. The user enters a question in the text box and presses the submit button, which sends the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[0399] 2. Communication with the server: When a user submits a question, the user device sends the question in JSON format to the server using an HTTP POST request. Upon receiving the response from the server, the user device parses it and displays it to the user.

[0400] Product information gathering and query response in physical stores

[0401] 1. Product information collection: The server collects and analyzes product information sold in physical stores. This function obtains information from physical store databases and public product catalogs.

[0402] 2. Query answering and sentiment analysis: When a user enters a product question in a physical store, the question is sent to the server, and the generative model generates an appropriate answer. At the same time, the sentiment engine analyzes the user's sentiment and adjusts the answer accordingly.

[0403] Usage example

[0404] If a user opens a smartphone app and types the question, "What is the battery life of my smartphone?", the server receives the query, the emotion engine analyzes the user's emotion as "neutral," the generative model generates an appropriate answer, and the response, "The latest smartphones feature fast processing and high-quality cameras," is sent to the user's device.

[0405] Prompt Sentence Examples

[0406] If a user asks "What are the features of the latest smartphones?" and sentiment analysis detects "joy,"

[0407] "We're glad you enjoyed it! The latest smartphones feature fast processing and high-quality cameras," the response provided reads.

[0408] This system improves the user experience by providing answers that reflect the user's feelings.

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

[0410] Step 1:

[0411] The user enters a query into the question interface on the terminal and presses the "Submit" button. The input is the user query text, which is the question or information the user wants to know. The terminal converts this text into JSON format and sends it to the server using an HTTP POST request. The input data is the user query (e.g., "What is the battery life of my smartphone?"), and the output is the JSON data that is sent to the server.

[0412] Step 2:

[0413] The server receives queries from the device and analyzes the query contents. The input is JSON data sent from the device, and natural language processing techniques are used for analysis. The server tokenizes the query using libraries such as "spaCy" and "NLTK" and extracts the necessary information. Data processing involves tokenization, normalization, and extraction of the necessary information, and the analyzed query data is obtained as output.

[0414] Step 3:

[0415] The server inputs the parsed query data into the generative model. This input data is the parsed query data. The generative model uses a pre-trained natural language processing algorithm to generate the optimal answer to the query. The output is the answer text generated by the generative model. Specifically, the generative model generates appropriate information from the query and generates data.

[0416] Step 4:

[0417] The server uses an emotion engine to analyze the user's emotion when inputting. The input requires the user's query text, and emotion recognition uses technologies such as the "Emotion Recognition API" and "Facial Expression Recognition API." The emotion engine analyzes the query text and identifies the user's emotion. Specifically, it extracts emotion labels from the text. The output is the emotion analysis result (e.g., "neutral," "joy," "anger," etc.).

[0418] Step 5:

[0419] The server combines the answer from the generative model with the emotion analysis results from the emotion engine. The input data required is the answer text and emotion label. The server adjusts the generated answer based on the emotion label and returns the optimal answer to the user. Data processing involves adjusting the response message according to the emotion label. The adjusted final answer text is obtained as the output.

[0420] Step 6:

[0421] The server formats the final answer text and sends it to the user's device. The input is the adjusted final answer text, which is then processed into a format that the user's device can understand. The specific operation is to send a response in JSON format via an HTTP POST request. The output is the final answer data sent to the user's device.

[0422] Step 7:

[0423] The user device receives the final response data from the server and displays it on the user interface. The input is the JSON data of the final response sent from the server, which is parsed and converted into a text format that the user can understand. The specific operation is to display the response content on an interface built with HTML / CSS or React Native. The output is the answer text that is displayed to the user.

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

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

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

[0427] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0440] The present invention is a system for collecting and analyzing political information and providing it to users in an easily understandable manner. A specific embodiment of this system will be described below.

[0441] System Overview

[0442] This system includes a server, a user terminal, and a generative model. The server collects and analyzes political information, and the generative model uses the collected information to generate appropriate answers to user queries. The user terminal provides an interface for users to access the system and input queries.

[0443] Server Features

[0444] Data collection

[0445] The server periodically collects political information from official government websites and parliamentary record databases. Specifically, it uses APIs and web scraping technology to obtain information on campaign promises and parliamentary responses. This collection process is achieved using libraries such as "BeautifulSoup" and "Scrapy."

[0446] Data analysis and preprocessing

[0447] The collected information is parsed and preprocessed on the server using natural language processing techniques (e.g., NLTK or spaCy) to tokenize, normalize, remove stop words, etc. The preprocessed data is then used as a training dataset for the generative model.

[0448] Training a generative model

[0449] The server uses the preprocessed data to train a generative model, which uses natural language processing techniques to learn to generate appropriate answers to user queries. During the training process, the dataset is divided into training data and validation data, and the model parameters are optimized.

[0450] Query Processing and Answer Generation

[0451] When a user submits a query, the server receives the query and inputs it into the generative model. The generative model generates a response to the query and returns the result to the server. The server then formats the response and sends it to the user's device.

[0452] User device functions

[0453] Question Interface

[0454] The user terminal provides a question interface where the user can enter a query. The user enters a question in a text box and presses the "Submit" button to send the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[0455] Communicating with the Server

[0456] When a user submits a question, the user device sends the question in JSON format to the server using an HTTP POST request. Upon receiving the response from the server, the user device parses it and displays it to the user.

[0457] User operations

[0458] Launching the app

[0459] The user launches the application on their device.

[0460] Enter a question

[0461] The user enters their question into the question interface and presses the "Submit" button. For example, they might enter, "What is the current discussion about the consumption tax increase?"

[0462] Confirm answer

[0463] The user checks the response from the server displayed on the device. For example, the response may read, "Recent discussions in the Diet about raising the consumption tax have focused on the burden on living expenses and the impact on small and medium-sized businesses."

[0464] Through the above-described embodiment, users can easily obtain political information that they are interested in. Furthermore, by using a generative model, it becomes possible to provide complex information in an easy-to-understand manner.

[0465] The processing flow will be explained below.

[0466] Step 1: The server gathers political information

[0467] The server accesses the government's official website and meeting minutes database, and collects information on public pledges and parliamentary responses using APIs and web scraping technology.

[0468] Specifically, it uses libraries such as "BeautifulSoup" and "Scrapy" to extract the necessary information from web pages.

[0469] The collected information is stored in a database.

[0470] Step 2: The server parses and preprocesses the data

[0471] The server tokenizes the collected political information and analyzes it using natural language processing (NLP) techniques.

[0472] We use NLP libraries such as "NLTK" and "spaCy" to preprocess the data by tokenizing, normalizing, and removing stop words.

[0473] The preprocessed data is prepared as a training dataset for a generative model.

[0474] Step 3: The server trains the generative model

[0475] The server uses the preprocessed data to train a generative model (e.g., GPT-4).

[0476] In the training process, the dataset is divided into training data and validation data, and the parameters of the generative model are optimized.

[0477] Once trained, the generative model is able to generate appropriate answers to user queries.

[0478] Step 4: The server deploys the generative model

[0479] The server deploys the trained generative model as an API, making it accessible from outside.

[0480] Set up a Restful API or GraphQL API and set up an endpoint to receive queries from users.

[0481] Step 5: User enters and submits question

[0482] The terminal displays an interface for the user to enter a question.

[0483] The user enters a question of interest and presses the "Submit" button. For example, "What is the current discussion about the consumption tax increase?"

[0484] Step 6: The device sends the question to the server

[0485] When a user submits a question, the device sends the question in JSON format to the server.

[0486] Send your question to the server's API endpoint using an HTTP POST request.

[0487] Step 7: The server receives the question and inputs it into the generative model

[0488] The server inputs questions received from users into the generative model.

[0489] A generative model generates appropriate answers to questions.

[0490] Step 8: The server receives and formats the generative model's answer

[0491] The server parses the answers received from the generative model and formats them as needed for display to the user.

[0492] Step 9: The server sends the formatted response to the device

[0493] The server sends the formatted response to the user terminal.

[0494] The answer is returned to the device as an HTTP response.

[0495] Step 10: The device displays the response from the server.

[0496] The terminal parses the response received from the server and displays it in a user-friendly format.

[0497] Users can check the displayed answers and get the answer to their question. For example, they might see something like, "Recent discussions in the Diet about raising the consumption tax have focused on the cost of living and the impact on small and medium-sized businesses."

[0498] Example 1

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

[0500] Conventional systems for collecting and analyzing political information collect information infrequently, making it difficult for users to instantly obtain the latest political information. Furthermore, the collected information was not pre-processed or analyzed efficiently, resulting in low accuracy of responses to users. Furthermore, there were issues with the usability of the user interface, making it difficult to input appropriate queries.

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

[0502] In this invention, the server includes means for periodically collecting political information, means for analyzing and preprocessing the collected political information using natural language processing technology, and means for training a generative model using the analyzed information, thereby enabling users to quickly and accurately obtain the latest political information.

[0503] "Political information" refers to information related to political decision-making and policies, such as government and parliamentary pledges and parliamentary responses.

[0504] A "generative model" is an algorithm or method that is trained using natural language processing techniques to generate appropriate answers to user queries.

[0505] "Natural language processing technology" is a technology that enables computers to understand, analyze, and generate natural language that humans use on a daily basis, and involves a wide range of processing including tokenization, normalization, and removal of stop words.

[0506] A "query" is a question or inquiry that a user enters to obtain desired information.

[0507] A "user terminal" is a device that a user uses to access and operate the system, and includes smartphones, tablets, personal computers, etc.

[0508] "JSON format" is an abbreviation for JavaScript Object Notation, and is a text format for structuring and representing data.

[0509] An "HTTP POST request" is a request method that uses the Hypertext Transfer Protocol to send data to a server, and is primarily used to send form data or upload files.

[0510] "Web scraping technology" is a method for automatically extracting and collecting information from websites, and is implemented using programming languages ​​and libraries.

[0511] A "question interface" is a UI (user interface) component that provides a screen and operating environment for users to input and submit queries, and includes a text box and a submit button.

[0512] MODE FOR CARRYING OUT THE INVENTION

[0513] The present invention provides a system for collecting and analyzing political information and providing it to users in an easily understandable manner. This system includes a server, a user terminal, and a generative model. Specific embodiments of this system are described below.

[0514] Server Features

[0515] 1. Data Collection

[0516] The server periodically collects political information from official government websites and parliamentary record databases. Specifically, it uses APIs and web scraping technology to obtain information on campaign promises and parliamentary responses. This collection process is carried out using web scraping libraries such as "BeautifulSoup" and "Scrapy."

[0517] 2. Data analysis and preprocessing

[0518] The collected information is analyzed and preprocessed on the server. This analysis uses natural language processing technologies such as "NLTK" and "spaCy" to tokenize, normalize, and remove stop words from the data. For example, minutes data is broken down into sentences such as "The consumption tax increase is being discussed in the Diet in relation to the cost of living," and important keywords are extracted.

[0519] 3. Training the generative model

[0520] The server uses the preprocessed data to train a generative model. This generative model uses natural language processing techniques to learn to generate appropriate answers to user queries. The server divides the dataset into training data and validation data, trains the model, and finds the optimal parameters. This process uses machine learning frameworks such as TensorFlow and PyTorch.

[0521] 4. Answer generation

[0522] When a user submits a query, the server inputs the query into the generative model. The generative model generates a response to the query and returns the result to the server. The server formats the response and sends it to the user's device. For example, if the query was "What is the current discussion about the consumption tax increase?", the model would generate a response such as "The current discussion about the consumption tax increase in the Diet has focused on the burden of living expenses and the impact on small and medium-sized businesses."

[0523] User device functions

[0524] 1. Question Interface

[0525] The user terminal provides a question interface where the user can enter a query. The user enters a question in a text box and presses the "Submit" button to send the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[0526] 2. Communication with the server

[0527] When a user submits a question, the device converts the question into JSON format and sends it to the server as an HTTP POST request using the axios library. Upon receiving the response from the server, the device parses it and displays it to the user.

[0528] User operations

[0529] 1. Launch the app

[0530] A user launches an application on their device, which can be a smartphone, tablet, personal computer, or other device.

[0531] 2. Enter your question

[0532] Users enter their questions into the question interface and press the "Submit" button. Examples of questions include "What's the latest on recent environmental policy?" or "What are the talking points regarding health care reform?"

[0533] 3. Confirm answer

[0534] The user checks the response from the server displayed on the device. For example, a response such as "The latest information on environmental policy is that the main measures currently being implemented are ____" is displayed, and the user can check the details.

[0535] Through the above-described embodiment, users can easily obtain political information that interests them. Furthermore, by using a generative model, it becomes possible to provide complex information in an easy-to-understand manner. This system allows for the prompt provision of the latest political information, improving the reliability of the information and the ease of use of the user interface.

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

[0537] System processing steps

[0538] Server Processing Steps

[0539] Step 1: Data collection

[0540] Description: The server periodically collects political information, specifically using web scraping techniques and APIs to retrieve information from official government websites and parliamentary record databases.

[0541] Input: Official government website URL, API endpoint

[0542] Output: Political information (campaign promises, parliamentary responses, etc.)

[0543] What it does: It uses BeautifulSoup to parse information from websites and Scrapy to crawl web pages.

[0544] Step 2: Data analysis and preprocessing

[0545] Description: Analyzes and pre-processes collected political information, using natural language processing techniques like NLTK and spaCy to tokenize, normalize, and remove stop words from the data.

[0546] Input: Collected political information (text data)

[0547] Output: Preprocessed text data (tokenized, normalized, and stopword-removed)

[0548] Specific operation: The server uses "spaCy" to tokenize sentences and remove unnecessary words. For example, minutes data is converted into the format "The consumption tax increase is being discussed in the Diet in relation to the burden of living expenses."

[0549] Step 3: Training the generative model

[0550] Description: Train a generative model using preprocessed data. Split the dataset into training and validation data and optimize the model parameters.

[0551] Input: Preprocessed text data

[0552] Output: A trained generative model

[0553] How it works: The server trains the model using the TensorFlow or PyTorch framework, splitting the dataset into 80% for training and 20% for validation.

[0554] Step 4: Answer Generation

[0555] Description: When a user submits a query, the server inputs the query into the generative model and sends the answer generated by the model to the user's device.

[0556] Input: User query

[0557] Output: The answer from the generative model

[0558] How it works: The server receives a user query, inputs it into the model, and generates a response. For example, in response to the query "What has the recent discussion been about regarding the consumption tax increase?", the server generates the answer "The recent discussion about the consumption tax increase in the Diet has focused on the burden of living expenses and the impact on small and medium-sized businesses."

[0559] ---

[0560] User terminal processing steps

[0561] Step 5: Displaying the Question Interface

[0562] Description: The user terminal provides a question interface where the user can enter a query. The user enters the question here and presses the submit button.

[0563] Input: User Interface

[0564] Output: User query

[0565] Specific behavior: The interface is built using "HTML / CSS" and "React Native" and displays a text box and a submit button.

[0566] Step 6: Submit a query

[0567] Description: When a user enters a question and presses the submit button, the user's device converts the question into JSON format and sends an HTTP POST request to the server.

[0568] Input: User query

[0569] Output: Query data in JSON format

[0570] What it does: Uses the "axios" library to send JSON data containing the query to the server.

[0571] Step 7: Communicating with the Server

[0572] Description: The user terminal receives the response from the server, parses it and displays it in the user interface.

[0573] Input: JSON format response data from the server

[0574] Output: The response that is displayed to the user

[0575] Specific behavior: Receives JSON-formatted response data, parses it, and displays it to the user in an appropriate format.

[0576] ---

[0577] User operations

[0578] Step 8: Launch the app

[0579] Description: A user launches an application on their device.

[0580] Input: None

[0581] Output: Application home screen

[0582] Specific behavior: The user taps the app icon on the smartphone's home screen, or opens a web browser and accesses the specified URL.

[0583] Step 9: Enter your question

[0584] Description: The user enters their question into the question interface and presses the "Submit" button.

[0585] Input: User question (prompt)

[0586] Output: Query data sent to the server

[0587] What it does: Type "What's the latest on recent environmental policy?" or "Please explain the talking points on healthcare reform" into the text box and tap the send button.

[0588] Step 10: Check your answers

[0589] Description: The user checks the server's response displayed on the terminal.

[0590] Input: Response data from the server

[0591] Output: The response displayed in the user interface

[0592] Specific operation: The screen will display something like "As the latest information on environmental policy, the main measures currently being implemented are ____," and the user will confirm the details.

[0593] Through the above processing steps, the system can provide political information to users efficiently and quickly.

[0594] (Application example 1)

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

[0596] In modern online shopping site operations, policy changes and legal amendments can directly affect how products are handled and distributed. Therefore, it is necessary to quickly obtain the latest policy information and respond appropriately. However, conventional methods require a great deal of effort to collect and analyze policy information, which often results in delayed responses. There is a need for a method that solves this problem and allows online shopping site operators to efficiently respond to policy and legal amendments.

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

[0598] In this invention, the server includes means for collecting political information, means for analyzing and preprocessing the collected political information, means for training a generative model using the analyzed information, means for receiving queries from users and inputting them into the generative model, means for receiving and transmitting answers from the generative model to the user queries, means for supporting the operator of an online shopping site to respond quickly to policy changes and legal amendments, and a smartphone application that provides policy information in response to questions from users based on the above means, thereby enabling the operator of an online shopping site to efficiently respond to policy changes and legal amendments.

[0599] "Political information" is a concept that includes information related to policies and laws provided by the government or parliament.

[0600] "Analysis" refers to the process of breaking down collected data into an understandable format and processing it.

[0601] "Preprocessing" refers to a series of operations performed to prepare data for easier analysis.

[0602] A "generative model" refers to an algorithm or system that is trained to generate relevant answers to user queries.

[0603] "Query" refers to a question or request that a user enters into a system to obtain information.

[0604] "Answer" refers to the information or content that the system provides in response to a user's query.

[0605] "Smartphone application" refers to software that runs on a smartphone and is an application developed to provide specific functions or services.

[0606] "Policy change" refers to the modification of existing policies or the introduction of new policies by the government or parliament.

[0607] "Legal amendment" refers to the revision of existing laws and regulations, adding or amending new provisions or rules.

[0608] "Online shopping site operator" refers to an individual or company that manages and operates a website that sells products and services over the Internet.

[0609] The present invention is a system that uses a server, a user terminal, and a generative model to collect and analyze political information and provide it to users in an easy-to-understand manner. Specific embodiments of this system are described below.

[0610] System Overview

[0611] This system consists of a server that collects political information from official government and parliamentary websites and analyzes and preprocesses the data, a generative model that accepts queries from users and provides answers, and a user terminal with an interface for users to input queries.

[0612] Server Features

[0613] Data collection

[0614] The server periodically collects political information. To do this, it uses APIs and web scraping technology to obtain data from official government websites and meeting minutes databases. Specific methods include using libraries such as "BeautifulSoup" and "Scrapy."

[0615] Data analysis and preprocessing

[0616] The collected political information is analyzed and preprocessed on the server using natural language processing technologies such as spaCy and NLTK, which tokenize, normalize, and remove stop words from the data, making it suitable for training.

[0617] Training a generative model

[0618] The server uses the preprocessed data to train a generative model, which is designed to generate appropriate answers to user queries using artificial intelligence techniques. The training process uses a large dataset and optimizes the model by dividing the dataset into training and validation.

[0619] Query Processing and Answer Generation

[0620] When a user sends a query to the server, the server inputs the query into the generative model, which generates an appropriate answer for the question and returns the result to the server, which formats the answer and sends it to the user's device.

[0621] User device functions

[0622] Question Interface

[0623] The user terminal provides a question interface where the user can enter a query. Specifically, by entering a question in a text box and pressing the "Submit" button, the query is sent to the server. This is done using technologies such as "HTML / CSS" and "React Native."

[0624] Communicating with the Server

[0625] When a user submits a query, the user device sends the query in JSON format to the server using an HTTP POST request. After receiving a response from the server, the user device parses the response and displays it to the user.

[0626] Specific examples

[0627] For example, a user might enter a question into a smartphone application, such as "Please tell me about the new import regulations." The server receives this query and inputs it into a generative model. The generative model generates an appropriate answer based on the collected political information and returns it to the server. The server formats the answer and sends it to the user's device. The user's device displays this answer, and the user can obtain information such as, "Regarding recent import regulations, new tariff rates have been set to protect domestic producers. Specifically, standards for food additives and cosmetics have been tightened, which has resulted in an increase in inspection procedures."

[0628] Example prompt sentence:

[0629] "Please tell me about the new import regulations."

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

[0631] Step 1: Data collection

[0632] The server periodically collects political information. Specifically, it uses APIs and web scraping technology to obtain campaign promises and parliamentary responses from official government websites and meeting minutes databases. Libraries such as "BeautifulSoup" and "Scrapy" are used for this process. The input is the website URL or API endpoint, and the output is the text data of the obtained political information.

[0633] Step 2: Data analysis and preprocessing

[0634] The collected text data is analyzed and preprocessed on the server. Specifically, natural language processing techniques are used to tokenize, normalize, and remove stop words from the data. For this purpose, "spaCy" and "NLTK" are used. The input is text data, and the output is preprocessed token data.

[0635] Step 3: Training the generative model

[0636] The server uses the preprocessed token data to train a generative model. This generative model is designed to generate appropriate answers to user queries. A natural language generation model such as GPT-2 is used to train the generative model. The input is the preprocessed token data, and the output is the trained model.

[0637] Step 4: Receiving a user query

[0638] A user accesses a smartphone application, inputs a query into the question interface, for example, "Please tell me about the new import regulations," and presses the submit button. The input is the user's query, and the output is the query data sent to the server.

[0639] Step 5: Query processing and answer generation

[0640] When the server receives a query from a user, it inputs the query into the generative model, which generates an appropriate answer based on the query and returns the result to the server. The input is the user's query, and the output is the generated answer data.

[0641] Step 6: Format and submit your response

[0642] The server formats the answer returned by the generative model into an easy-to-understand format, and then sends the answer to the user's device. The input is the generated answer data, and the output is the formatted answer.

[0643] Step 7: Display the answer to the user

[0644] The user terminal receives the formatted answer sent from the server and displays it to the user. The user can check the answer displayed on the terminal and obtain the necessary information. The input is the formatted answer from the server, and the output is the information displayed on the user's display.

[0645] Example prompt sentence:

[0646] "Please tell me about the new import regulations."

[0647] The above is an explanation of each processing step of this system and its specific operation.

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

[0649] The present invention is a system that collects and analyzes political information, provides it to users in an easy-to-understand manner, and combines it with an emotion engine that recognizes the user's emotions. Specific embodiments of this system are described below.

[0650] System Overview

[0651] This system includes a server, a user terminal, a generative model, and an emotion engine. The server collects and analyzes political information, and the generative model uses the collected information to generate appropriate answers to user queries. The emotion engine recognizes the emotion of the user when entering a query and adjusts the content of the answer accordingly. The user terminal provides an interface for users to access the system and enter queries.

[0652] Server Features

[0653] Data collection

[0654] The server periodically collects political information from official government websites and parliamentary record databases. Specifically, it uses APIs and web scraping technology to obtain information on campaign promises and parliamentary responses. This collection process is achieved using libraries such as "BeautifulSoup" and "Scrapy." The collected information is then stored in a database.

[0655] Data analysis and preprocessing

[0656] The collected information is parsed and preprocessed on the server using natural language processing techniques (e.g., NLTK or spaCy) to tokenize, normalize, remove stop words, etc. The preprocessed data is then prepared as a training dataset for the generative model.

[0657] Training a generative model

[0658] The server uses the preprocessed data to train a generative model. The generative model uses natural language processing techniques to learn to generate appropriate answers to user queries. During the training process, the dataset is divided into training data and validation data, and the model parameters are optimized. After training is complete, the generative model is able to generate appropriate answers to user queries.

[0659] Query Processing and Answer Generation

[0660] When a user submits a query, the server receives the query and inputs it into the generative model. The emotion engine simultaneously analyzes the user's emotion when submitting the query and provides that information to the generative model. The generative model generates a response based on the query and emotion information and returns the result to the server. The server then formats the response and sends it to the user's device.

[0661] Emotion Engine Functions

[0662] Emotion analysis

[0663] The emotion engine analyzes the emotions expressed when a user enters a query. Analysis methods include emotion recognition from text input, emotion recognition from voice input, and even emotion recognition by analyzing the user's facial image. Using technologies such as "Emotion Recognition API" and "Facial Expression Recognition API," the engine can analyze user emotions with high accuracy.

[0664] User device functions

[0665] Question Interface

[0666] The user terminal provides a question interface where the user can enter a query. The user enters a question in a text box and presses the "Submit" button to send the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[0667] Communicating with the Server

[0668] When a user submits a question, the user device sends the question in JSON format to the server using an HTTP POST request. Upon receiving the response from the server, the user device parses it and displays it to the user.

[0669] User operations

[0670] Launching the app

[0671] The user launches the application on their device.

[0672] Enter a question

[0673] The user enters their question into the question interface and presses the "Submit" button. For example, they might enter, "What is the current discussion about the consumption tax increase?"

[0674] Confirm answer

[0675] The user checks the response from the server displayed on the device. For example, it might say, "Recent discussions in the Diet about the consumption tax increase have focused on the burden on living expenses and the impact on small and medium-sized businesses." The emotion engine also analyzes the user's emotions and adjusts the response accordingly, allowing the user to obtain information in a format that is easier to understand.

[0676] Through the above-described embodiment, users can easily obtain political information that interests them, and the information can be provided in an appropriate format through sentiment analysis. By combining a generative model and a sentiment engine, it is possible to improve the quality of responses to users and enhance the user experience.

[0677] The processing flow will be explained below.

[0678] Step 1: The server gathers political information

[0679] The server accesses the government's official website and meeting minutes database, and collects information on public pledges and parliamentary responses using APIs and web scraping technology.

[0680] Specifically, it uses libraries such as "BeautifulSoup" and "Scrapy" to extract the necessary information from web pages.

[0681] The collected information is stored in a database.

[0682] Step 2: The server parses and preprocesses the data

[0683] The server tokenizes the collected political information and analyzes it using natural language processing (NLP) techniques.

[0684] We use NLP libraries such as "NLTK" and "spaCy" to preprocess the data by tokenizing, normalizing, and removing stop words.

[0685] The preprocessed data is prepared as a training dataset for a generative model.

[0686] Step 3: The server trains the generative model

[0687] The server uses the preprocessed data to train a generative model (e.g., GPT-4).

[0688] In the training process, the dataset is divided into training data and validation data, and the parameters of the generative model are optimized.

[0689] Once trained, the generative model is able to generate appropriate answers to user queries.

[0690] Step 4: The server deploys the generative model

[0691] The server deploys the trained generative model as an API, making it accessible from outside.

[0692] Set up a Restful API or GraphQL API and set up an endpoint to receive queries from users.

[0693] Step 5: User enters and submits question

[0694] The terminal displays an interface for the user to enter a question.

[0695] The user enters a question of interest and presses the "Submit" button. For example, "What is the current discussion about the consumption tax increase?"

[0696] Step 6: The device sends the question to the server

[0697] When a user submits a question, the device sends the question in JSON format to the server.

[0698] Send your question to the server's API endpoint using an HTTP POST request.

[0699] Step 7: The server receives the question and inputs it into the emotion engine

[0700] The server inputs the question received from the user into the emotion engine.

[0701] The emotion engine analyzes the question content and the context of the user's input to recognize their emotional state.

[0702] Step 8: The emotion engine provides emotion information to the generative model

[0703] The emotion engine provides the recognized emotion information to the generative model.

[0704] The generative model generates answers with appropriate tone and content based on emotional information.

[0705] Step 9: The server receives and formats the generative model's answer

[0706] The server parses the answers received from the generative model and formats them as needed for display to the user.

[0707] Step 10: The server sends the formatted response to the device

[0708] The server sends the formatted response to the user terminal.

[0709] The answer is returned to the device as an HTTP response.

[0710] Step 11: The device displays the response from the server.

[0711] The terminal parses the response received from the server and displays it in a user-friendly format.

[0712] Users can check the displayed answers and get answers to their questions. For example, they might see something like, "Recent discussions in the Diet about the consumption tax increase have focused on the cost of living and the impact on small and medium-sized businesses." Furthermore, the emotion engine provides information in a tone that reflects the user's emotions, making it easier for users to understand.

[0713] Example 2

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

[0715] Conventional political information gathering systems have had difficulty efficiently collecting, analyzing, and providing information of interest to users in an easy-to-understand format. Furthermore, they were unable to generate appropriate responses that took the user's emotions into account, resulting in a poor user experience. It is necessary to solve this problem.

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

[0717] In this invention, the server includes means for collecting political information, means for analyzing and preprocessing the political information, means for training a data model using the analyzed information, means for receiving queries from users and inputting them into the data model, means for analyzing the user's emotions, and means for transmitting answers generated by adding the emotional information, thereby enabling users to efficiently collect and understand political information and receive responses that take their emotions into consideration.

[0718] "Political information" refers to official document information relating to the government or parliament and the content of parliamentary debates.

[0719] "Analysis" refers to the process of breaking down collected political information and understanding its meaning and structure.

[0720] "Preprocessing" refers to the process of formatting the parsed information into a format that can be used by the data model.

[0721] A "data model" is a model trained using natural language processing techniques to generate appropriate responses based on user queries.

[0722] "Query" refers to a question or request that a user enters into a system to obtain information about their concern.

[0723] "Sentiment analysis" refers to the technology of identifying the sentiment contained in a user's query or input and tailoring responses based on that sentiment.

[0724] "Sending a response" refers to the process of providing the answer generated by the generative model to the user terminal and displaying it to the user.

[0725] The present invention is a system that collects and analyzes political information, provides it to users in an easy-to-understand manner, and combines it with an emotion engine that recognizes the user's emotions. Specific embodiments of this system are described below.

[0726] Server Features

[0727] Data collection

[0728] The server collects political information from official government websites and meeting minutes databases. Specifically, it obtains the information using APIs and web scraping techniques. This processing is achieved using libraries such as "BeautifulSoup" and "Scrapy." The collected information is then stored in a database.

[0729] Data analysis and preprocessing

[0730] The server analyzes and preprocesses the collected information using natural language processing techniques such as NLTK and spaCy. The analysis process includes tokenization, normalization, and stop word removal. The preprocessed data is then prepared as a training dataset for the generative model.

[0731] Training a generative model

[0732] The server uses the preprocessed data to train a generative model. Natural language processing techniques such as Transformer and BERT are used for the generative model. During the training process, the dataset is divided into training data and validation data, and the model parameters are optimized. After training is complete, the generative model is able to generate appropriate answers to user queries.

[0733] Emotion Engine Functions

[0734] Emotion analysis

[0735] The emotion engine analyzes the emotions expressed when a user enters a query. This can be done by recognizing emotions from text input, voice input, or even by analyzing facial images. Using the "Emotion Recognition API" and "Facial Expression Recognition API," it analyzes user emotions with high accuracy.

[0736] User device functions

[0737] Question Interface

[0738] The user terminal provides a question interface where users can enter queries. This interface is built using technologies such as "HTML / CSS" and "React Native." Users can enter a question in the text box and press the "Submit" button to send the query to the server.

[0739] Communicating with the Server

[0740] When a user submits a question, the device sends it to the server in JSON format using an HTTP POST request. Upon receiving a response from the server, the device parses the information and displays it to the user.

[0741] User operations

[0742] A user launches the application on their device and enters "What has been discussed recently about the consumption tax increase?" into the question interface. When the user presses the "Send" button, the query is sent to the server. The server inputs this query into a generative model, and an emotion engine analyzes the user's emotions. The generative model then generates a response based on the query and emotion information and returns it to the server. The server formats the response and sends it to the user's device, where the user can view it. For example, the response may appear as "Recent discussions about the consumption tax increase in the Diet have focused on the burden of living costs and the impact on small and medium-sized businesses."

[0743] Through this system, users can efficiently collect and analyze political information they are interested in and obtain it in an appropriate format. By combining a generative model with an emotion engine, it is possible to improve the quality of responses to users and enhance the user experience.

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

[0745] Step 1:

[0746] The server accesses the government's official website and the minutes database and collects information using APIs and web scraping technology. It uses libraries such as "BeautifulSoup" and "Scrapy" to analyze web pages and obtain information on campaign promises and parliamentary responses. The input is the government's official website and the minutes database, and the output is a dataset of collected political information.

[0747] Step 2:

[0748] The server stores the collected political information in a database. Specifically, it formats the information into an appropriate format and stores it in the database. This database uses "MySQL" or "PostgreSQL." The input is the collected political information, and the output is the data stored in the database.

[0749] Step 3:

[0750] The server retrieves the collected data from the database and performs natural language processing using NLTK and spaCy. Here, the data is tokenized, normalized, and stop words are removed. The input is political information retrieved from the database, and the output is the preprocessed data.

[0751] Step 4:

[0752] The server uses the preprocessed data as a training dataset for a generative model. It trains the data model using natural language processing techniques such as Transformer and BERT. During the training process, the dataset is split into training data and validation data, and the model parameters are optimized. The input is the preprocessed data, and the output is a trained generative model.

[0753] Step 5:

[0754] A user starts the application on their device and inputs a query into the question interface. For example, they input, "What is the current discussion about the consumption tax increase?" The input is the query from the user, and the output is the transmission of the query by the device.

[0755] Step 6:

[0756] The terminal converts the query entered by the user into JSON format and sends it to the server via an HTTP POST request. The input is the query from the user, and the output is the request sent to the server.

[0757] Step 7:

[0758] The server receives a user query and inputs the received query into the generative model. The input is the query sent from the terminal, and the output is the query input to the generative model.

[0759] Step 8:

[0760] The emotion engine analyzes the emotion of the user when they enter a query. This is done using text analysis or speech analysis. For example, it uses the Emotion Recognition API or Facial Expression Recognition API. The input is the user's query, and the output is the analyzed emotion information.

[0761] Step 9:

[0762] Based on the emotion information provided by the emotion engine, the generative model generates a response to the query. The input is the query and emotion information, and the output is the response result. For example, the generated response might be, "Recent discussions in the Diet about the consumption tax increase have focused on the burden of living expenses and the impact on small and medium-sized businesses."

[0763] Step 10:

[0764] The server formats the response results obtained from the generative model. It formats the results into an appropriate format and sends them to the user's device. The input is the response results from the generative model, and the output is the response formatted for sending to the device.

[0765] Step 11:

[0766] The device receives the response from the server, parses it from JSON format, and displays it in a user-friendly format based on that information. The input is the formatted response, and the output is the response that is displayed to the user. For example, it might say, "Recent discussions in the Diet about raising the consumption tax have focused on the cost of living and the impact on small and medium-sized businesses."

[0767] (Application example 2)

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

[0769] In today's information society, it is important to quickly and accurately collect political and product information and provide it to users in an easy-to-understand manner. However, conventional systems have difficulty analyzing user emotions and adjusting responses accordingly, resulting in a poor user experience. Furthermore, in brick-and-mortar stores, there is a similar lack of support that reflects user emotions, making it difficult to improve customer satisfaction.

[0770] The identification processing 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 collecting political information, means for analyzing and preprocessing the collected political information, means for training a generative model using the analyzed information, means for receiving a query from a user and inputting it into the generative model, means for receiving and sending the generative model's response to the user's query, means for analyzing the user's emotion at the time of query input, means for adjusting the generated response based on the emotion analysis result, means for collecting and analyzing product information in a physical store, means for receiving a user's query regarding product information in the physical store and providing an answer, and means for adjusting customer service based on the emotion analysis result. This makes it possible to provide responses that reflect the user's emotion and adjust customer service in a physical store in real time.

[0771] "Political information" refers to data related to public policies, such as campaign promises and parliamentary responses provided by the government and parliament.

[0772] A "generative model" is an algorithm that is trained using natural language processing techniques to generate appropriate answers to user queries.

[0773] "Sentiment analysis" is the process of identifying emotions from a user's text or voice input.

[0774] A "query" is a question or request that a user enters into a system.

[0775] A "brick and mortar store" is a commercial establishment that exists in a physical location and offers goods and services.

[0776] The "emotion engine" is a system component that analyzes the user's emotions and adjusts responses accordingly.

[0777] "Product information" refers to data about the features and specifications of products sold in physical stores.

[0778] A "user terminal" is an electronic device used by a user to access the system and enter queries.

[0779] "Data collection" refers to the process of obtaining necessary information from official government websites, meeting minutes databases, etc.

[0780] "Natural language processing technology" is an artificial intelligence technology for understanding and processing human language.

[0781] An "HTTP POST request" is one of the communication protocols for sending data to a web server.

[0782] "Analysis" is the process of processing and formatting collected data.

[0783] "Preprocessing" refers to operations such as tokenizing, normalizing, and removing stop words from data prior to data analysis.

[0784] A "generated answer" is a response provided by a generative model to a user's query.

[0785] A "training dataset" is a collection of data used to train a generative model.

[0786] This invention is a system that collects and analyzes political and product information, recognizes user emotions, and adjusts responses. This system includes a server, a user terminal, a generative model, and an emotion engine.

[0787] Server Features

[0788] 1. Data collection: The server periodically collects political information from official government websites and parliamentary record databases. Using APIs and web scraping technology, it retrieves information on campaign promises and parliamentary responses and stores the information in a database. Specifically, it uses libraries such as "BeautifulSoup" and "Scrapy."

[0789] 2. Data analysis and preprocessing: The collected information is parsed and preprocessed on the server. Natural language processing techniques (e.g., spaCy or NLTK) are used to tokenize, normalize, and remove stop words from the data. The preprocessed data is then prepared as a training dataset for the generative model.

[0790] 3. Training the generative model: The server uses the preprocessed data to train the generative model, which uses natural language processing techniques to learn to generate appropriate answers to user queries.

[0791] 4. Query processing and answer generation: When a user submits a query, the server receives the query and inputs it into the generative model. At the same time, the emotion engine analyzes the user's emotion when submitting the query and provides that information to the generative model. The generative model generates a response based on the query and emotion information and returns the result to the server. The server then formats the response and sends it to the user's device.

[0792] Emotion Engine Functions

[0793] 1. Emotion Analysis: The emotion engine analyzes the emotions expressed when a user enters a query. It recognizes emotions from text input, voice input, and even by analyzing the user's facial image. Specific technologies used include the "Emotion Recognition API" and "Facial Expression Recognition API."

[0794] User device functions

[0795] 1. Question interface: The user device provides an interface where the user can enter a query. The user enters a question in the text box and presses the submit button, which sends the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[0796] 2. Communication with the server: When a user submits a question, the user device sends the question in JSON format to the server using an HTTP POST request. Upon receiving the response from the server, the user device parses it and displays it to the user.

[0797] Product information gathering and query response in physical stores

[0798] 1. Product information collection: The server collects and analyzes product information sold in physical stores. This function obtains information from physical store databases and public product catalogs.

[0799] 2. Query answering and sentiment analysis: When a user enters a product question in a physical store, the question is sent to the server, and the generative model generates an appropriate answer. At the same time, the sentiment engine analyzes the user's sentiment and adjusts the answer accordingly.

[0800] Usage example

[0801] If a user opens a smartphone app and types the question, "What is the battery life of my smartphone?", the server receives the query, the emotion engine analyzes the user's emotion as "neutral," the generative model generates an appropriate answer, and the response, "The latest smartphones feature fast processing and high-quality cameras," is sent to the user's device.

[0802] Prompt Sentence Examples

[0803] If a user asks "What are the features of the latest smartphones?" and sentiment analysis detects "joy,"

[0804] "We're glad you enjoyed it! The latest smartphones feature fast processing and high-quality cameras," the response provided reads.

[0805] This system improves the user experience by providing answers that reflect the user's feelings.

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

[0807] Step 1:

[0808] The user enters a query into the question interface on the terminal and presses the "Submit" button. The input is the user query text, which is the question or information the user wants to know. The terminal converts this text into JSON format and sends it to the server using an HTTP POST request. The input data is the user query (e.g., "What is the battery life of my smartphone?"), and the output is the JSON data that is sent to the server.

[0809] Step 2:

[0810] The server receives queries from the device and analyzes the query contents. The input is JSON data sent from the device, and natural language processing techniques are used for analysis. The server tokenizes the query using libraries such as "spaCy" and "NLTK" and extracts the necessary information. Data processing involves tokenization, normalization, and extraction of the necessary information, and the analyzed query data is obtained as output.

[0811] Step 3:

[0812] The server inputs the parsed query data into the generative model. This input data is the parsed query data. The generative model uses a pre-trained natural language processing algorithm to generate the optimal answer to the query. The output is the answer text generated by the generative model. Specifically, the generative model generates appropriate information from the query and generates data.

[0813] Step 4:

[0814] The server uses an emotion engine to analyze the user's emotion when inputting. The input requires the user's query text, and emotion recognition uses technologies such as the "Emotion Recognition API" and "Facial Expression Recognition API." The emotion engine analyzes the query text and identifies the user's emotion. Specifically, it extracts emotion labels from the text. The output is the emotion analysis result (e.g., "neutral," "joy," "anger," etc.).

[0815] Step 5:

[0816] The server combines the answer from the generative model with the emotion analysis results from the emotion engine. The input data required is the answer text and emotion label. The server adjusts the generated answer based on the emotion label and returns the optimal answer to the user. Data processing involves adjusting the response message according to the emotion label. The adjusted final answer text is obtained as the output.

[0817] Step 6:

[0818] The server formats the final answer text and sends it to the user's device. The input is the adjusted final answer text, which is then processed into a format that the user's device can understand. The specific operation is to send a response in JSON format via an HTTP POST request. The output is the final answer data sent to the user's device.

[0819] Step 7:

[0820] The user device receives the final response data from the server and displays it on the user interface. The input is the JSON data of the final response sent from the server, which is parsed and converted into a text format that the user can understand. The specific operation is to display the response content on an interface built with HTML / CSS or React Native. The output is the answer text that is displayed to the user.

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

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

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

[0824] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0837] The present invention is a system for collecting and analyzing political information and providing it to users in an easily understandable manner. A specific embodiment of this system will be described below.

[0838] System Overview

[0839] This system includes a server, a user terminal, and a generative model. The server collects and analyzes political information, and the generative model uses the collected information to generate appropriate answers to user queries. The user terminal provides an interface for users to access the system and input queries.

[0840] Server Features

[0841] Data collection

[0842] The server periodically collects political information from official government websites and parliamentary record databases. Specifically, it uses APIs and web scraping technology to obtain information on campaign promises and parliamentary responses. This collection process is achieved using libraries such as "BeautifulSoup" and "Scrapy."

[0843] Data analysis and preprocessing

[0844] The collected information is parsed and preprocessed on the server using natural language processing techniques (e.g., NLTK or spaCy) to tokenize, normalize, remove stop words, etc. The preprocessed data is then used as a training dataset for the generative model.

[0845] Training a generative model

[0846] The server uses the preprocessed data to train a generative model, which uses natural language processing techniques to learn to generate appropriate answers to user queries. During the training process, the dataset is divided into training data and validation data, and the model parameters are optimized.

[0847] Query Processing and Answer Generation

[0848] When a user submits a query, the server receives the query and inputs it into the generative model. The generative model generates a response to the query and returns the result to the server. The server then formats the response and sends it to the user's device.

[0849] User device functions

[0850] Question Interface

[0851] The user terminal provides a question interface where the user can enter a query. The user enters a question in a text box and presses the "Submit" button to send the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[0852] Communicating with the Server

[0853] When a user submits a question, the user device sends the question in JSON format to the server using an HTTP POST request. Upon receiving the response from the server, the user device parses it and displays it to the user.

[0854] User operations

[0855] Launching the app

[0856] The user launches the application on their device.

[0857] Enter a question

[0858] The user enters their question into the question interface and presses the "Submit" button. For example, they might enter, "What is the current discussion about the consumption tax increase?"

[0859] Confirm answer

[0860] The user checks the response from the server displayed on the device. For example, the response may read, "Recent discussions in the Diet about raising the consumption tax have focused on the burden on living expenses and the impact on small and medium-sized businesses."

[0861] Through the above-described embodiment, users can easily obtain political information that they are interested in. Furthermore, by using a generative model, it becomes possible to provide complex information in an easy-to-understand manner.

[0862] The processing flow will be explained below.

[0863] Step 1: The server gathers political information

[0864] The server accesses the government's official website and meeting minutes database, and collects information on public pledges and parliamentary responses using APIs and web scraping technology.

[0865] Specifically, it uses libraries such as "BeautifulSoup" and "Scrapy" to extract the necessary information from web pages.

[0866] The collected information is stored in a database.

[0867] Step 2: The server parses and preprocesses the data

[0868] The server tokenizes the collected political information and analyzes it using natural language processing (NLP) techniques.

[0869] We use NLP libraries such as "NLTK" and "spaCy" to preprocess the data by tokenizing, normalizing, and removing stop words.

[0870] The preprocessed data is prepared as a training dataset for a generative model.

[0871] Step 3: The server trains the generative model

[0872] The server uses the preprocessed data to train a generative model (e.g., GPT-4).

[0873] In the training process, the dataset is divided into training data and validation data, and the parameters of the generative model are optimized.

[0874] Once trained, the generative model is able to generate appropriate answers to user queries.

[0875] Step 4: The server deploys the generative model

[0876] The server deploys the trained generative model as an API, making it accessible from outside.

[0877] Set up a Restful API or GraphQL API and set up an endpoint to receive queries from users.

[0878] Step 5: User enters and submits question

[0879] The terminal displays an interface for the user to enter a question.

[0880] The user enters a question of interest and presses the "Submit" button. For example, "What is the current discussion about the consumption tax increase?"

[0881] Step 6: The device sends the question to the server

[0882] When a user submits a question, the device sends the question in JSON format to the server.

[0883] Send your question to the server's API endpoint using an HTTP POST request.

[0884] Step 7: The server receives the question and inputs it into the generative model

[0885] The server inputs questions received from users into the generative model.

[0886] A generative model generates appropriate answers to questions.

[0887] Step 8: The server receives and formats the generative model's answer

[0888] The server parses the answers received from the generative model and formats them as needed for display to the user.

[0889] Step 9: The server sends the formatted response to the device

[0890] The server sends the formatted response to the user terminal.

[0891] The answer is returned to the device as an HTTP response.

[0892] Step 10: The device displays the response from the server.

[0893] The terminal parses the response received from the server and displays it in a user-friendly format.

[0894] Users can check the displayed answers and get the answer to their question. For example, they might see something like, "Recent discussions in the Diet about raising the consumption tax have focused on the cost of living and the impact on small and medium-sized businesses."

[0895] Example 1

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

[0897] Conventional systems for collecting and analyzing political information collect information infrequently, making it difficult for users to instantly obtain the latest political information. Furthermore, the collected information was not pre-processed or analyzed efficiently, resulting in low accuracy of responses to users. Furthermore, there were issues with the usability of the user interface, making it difficult to input appropriate queries.

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

[0899] In this invention, the server includes means for periodically collecting political information, means for analyzing and preprocessing the collected political information using natural language processing technology, and means for training a generative model using the analyzed information, thereby enabling users to quickly and accurately obtain the latest political information.

[0900] "Political information" refers to information related to political decision-making and policies, such as government and parliamentary pledges and parliamentary responses.

[0901] A "generative model" is an algorithm or method that is trained using natural language processing techniques to generate appropriate answers to user queries.

[0902] "Natural language processing technology" is a technology that enables computers to understand, analyze, and generate natural language that humans use on a daily basis, and involves a wide range of processing including tokenization, normalization, and removal of stop words.

[0903] A "query" is a question or inquiry that a user enters to obtain desired information.

[0904] A "user terminal" is a device that a user uses to access and operate the system, and includes smartphones, tablets, personal computers, etc.

[0905] "JSON format" is an abbreviation for JavaScript Object Notation, and is a text format for structuring and representing data.

[0906] An "HTTP POST request" is a request method that uses the Hypertext Transfer Protocol to send data to a server, and is primarily used to send form data or upload files.

[0907] "Web scraping technology" is a method for automatically extracting and collecting information from websites, and is implemented using programming languages ​​and libraries.

[0908] A "question interface" is a UI (user interface) component that provides a screen and operating environment for users to input and submit queries, and includes a text box and a submit button.

[0909] MODE FOR CARRYING OUT THE INVENTION

[0910] The present invention provides a system for collecting and analyzing political information and providing it to users in an easily understandable manner. This system includes a server, a user terminal, and a generative model. Specific embodiments of this system are described below.

[0911] Server Features

[0912] 1. Data Collection

[0913] The server periodically collects political information from official government websites and parliamentary record databases. Specifically, it uses APIs and web scraping technology to obtain information on campaign promises and parliamentary responses. This collection process is carried out using web scraping libraries such as "BeautifulSoup" and "Scrapy."

[0914] 2. Data analysis and preprocessing

[0915] The collected information is analyzed and preprocessed on the server. This analysis uses natural language processing technologies such as "NLTK" and "spaCy" to tokenize, normalize, and remove stop words from the data. For example, minutes data is broken down into sentences such as "The consumption tax increase is being discussed in the Diet in relation to the cost of living," and important keywords are extracted.

[0916] 3. Training the generative model

[0917] The server uses the preprocessed data to train a generative model. This generative model uses natural language processing techniques to learn to generate appropriate answers to user queries. The server divides the dataset into training data and validation data, trains the model, and finds the optimal parameters. This process uses machine learning frameworks such as TensorFlow and PyTorch.

[0918] 4. Answer generation

[0919] When a user submits a query, the server inputs the query into the generative model. The generative model generates a response to the query and returns the result to the server. The server formats the response and sends it to the user's device. For example, if the query was "What is the current discussion about the consumption tax increase?", the model would generate a response such as "The current discussion about the consumption tax increase in the Diet has focused on the burden of living expenses and the impact on small and medium-sized businesses."

[0920] User device functions

[0921] 1. Question Interface

[0922] The user terminal provides a question interface where the user can enter a query. The user enters a question in a text box and presses the "Submit" button to send the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[0923] 2. Communication with the server

[0924] When a user submits a question, the device converts the question into JSON format and sends it to the server as an HTTP POST request using the axios library. Upon receiving the response from the server, the device parses it and displays it to the user.

[0925] User operations

[0926] 1. Launch the app

[0927] A user launches an application on their device, which can be a smartphone, tablet, personal computer, or other device.

[0928] 2. Enter your question

[0929] Users enter their questions into the question interface and press the "Submit" button. Examples of questions include "What's the latest on recent environmental policy?" or "What are the talking points regarding health care reform?"

[0930] 3. Confirm answer

[0931] The user checks the response from the server displayed on the device. For example, a response such as "The latest information on environmental policy is that the main measures currently being implemented are ____" is displayed, and the user can check the details.

[0932] Through the above-described embodiment, users can easily obtain political information that interests them. Furthermore, by using a generative model, it becomes possible to provide complex information in an easy-to-understand manner. This system allows for the prompt provision of the latest political information, improving the reliability of the information and the ease of use of the user interface.

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

[0934] System processing steps

[0935] Server Processing Steps

[0936] Step 1: Data collection

[0937] Description: The server periodically collects political information, specifically using web scraping techniques and APIs to retrieve information from official government websites and parliamentary record databases.

[0938] Input: Official government website URL, API endpoint

[0939] Output: Political information (campaign promises, parliamentary responses, etc.)

[0940] What it does: It uses BeautifulSoup to parse information from websites and Scrapy to crawl web pages.

[0941] Step 2: Data analysis and preprocessing

[0942] Description: Analyzes and pre-processes collected political information, using natural language processing techniques like NLTK and spaCy to tokenize, normalize, and remove stop words from the data.

[0943] Input: Collected political information (text data)

[0944] Output: Preprocessed text data (tokenized, normalized, and stopword-removed)

[0945] Specific operation: The server uses "spaCy" to tokenize sentences and remove unnecessary words. For example, minutes data is converted into the format "The consumption tax increase is being discussed in the Diet in relation to the burden of living expenses."

[0946] Step 3: Training the generative model

[0947] Description: Train a generative model using preprocessed data. Split the dataset into training and validation data and optimize the model parameters.

[0948] Input: Preprocessed text data

[0949] Output: A trained generative model

[0950] How it works: The server trains the model using the TensorFlow or PyTorch framework, splitting the dataset into 80% for training and 20% for validation.

[0951] Step 4: Answer Generation

[0952] Description: When a user submits a query, the server inputs the query into the generative model and sends the answer generated by the model to the user's device.

[0953] Input: User query

[0954] Output: The answer from the generative model

[0955] How it works: The server receives a user query, inputs it into the model, and generates a response. For example, in response to the query "What has the recent discussion been about regarding the consumption tax increase?", the server generates the answer "The recent discussion about the consumption tax increase in the Diet has focused on the burden of living expenses and the impact on small and medium-sized businesses."

[0956] ---

[0957] User terminal processing steps

[0958] Step 5: Displaying the Question Interface

[0959] Description: The user terminal provides a question interface where the user can enter a query. The user enters the question here and presses the submit button.

[0960] Input: User Interface

[0961] Output: User query

[0962] Specific behavior: The interface is built using "HTML / CSS" and "React Native" and displays a text box and a submit button.

[0963] Step 6: Submit a query

[0964] Description: When a user enters a question and presses the submit button, the user's device converts the question into JSON format and sends an HTTP POST request to the server.

[0965] Input: User query

[0966] Output: Query data in JSON format

[0967] What it does: Uses the "axios" library to send JSON data containing the query to the server.

[0968] Step 7: Communicating with the Server

[0969] Description: The user terminal receives the response from the server, parses it and displays it in the user interface.

[0970] Input: JSON format response data from the server

[0971] Output: The response that is displayed to the user

[0972] Specific behavior: Receives JSON-formatted response data, parses it, and displays it to the user in an appropriate format.

[0973] ---

[0974] User operations

[0975] Step 8: Launch the app

[0976] Description: A user launches an application on their device.

[0977] Input: None

[0978] Output: Application home screen

[0979] Specific behavior: The user taps the app icon on the smartphone's home screen, or opens a web browser and accesses the specified URL.

[0980] Step 9: Enter your question

[0981] Description: The user enters their question into the question interface and presses the "Submit" button.

[0982] Input: User question (prompt)

[0983] Output: Query data sent to the server

[0984] What it does: Type "What's the latest on recent environmental policy?" or "Please explain the talking points on healthcare reform" into the text box and tap the send button.

[0985] Step 10: Check your answers

[0986] Description: The user checks the server's response displayed on the terminal.

[0987] Input: Response data from the server

[0988] Output: The response displayed in the user interface

[0989] Specific operation: The screen will display something like "As the latest information on environmental policy, the main measures currently being implemented are ____," and the user will confirm the details.

[0990] Through the above processing steps, the system can provide political information to users efficiently and quickly.

[0991] (Application example 1)

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

[0993] In modern online shopping site operations, policy changes and legal amendments can directly affect how products are handled and distributed. Therefore, it is necessary to quickly obtain the latest policy information and respond appropriately. However, conventional methods require a great deal of effort to collect and analyze policy information, which often results in delayed responses. There is a need for a method that solves this problem and allows online shopping site operators to efficiently respond to policy and legal amendments.

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

[0995] In this invention, the server includes means for collecting political information, means for analyzing and preprocessing the collected political information, means for training a generative model using the analyzed information, means for receiving queries from users and inputting them into the generative model, means for receiving and transmitting answers from the generative model to the user queries, means for supporting the operator of an online shopping site to respond quickly to policy changes and legal amendments, and a smartphone application that provides policy information in response to questions from users based on the above means, thereby enabling the operator of an online shopping site to efficiently respond to policy changes and legal amendments.

[0996] "Political information" is a concept that includes information related to policies and laws provided by the government or parliament.

[0997] "Analysis" refers to the process of breaking down collected data into an understandable format and processing it.

[0998] "Preprocessing" refers to a series of operations performed to prepare data for easier analysis.

[0999] A "generative model" refers to an algorithm or system that is trained to generate relevant answers to user queries.

[1000] "Query" refers to a question or request that a user enters into a system to obtain information.

[1001] "Answer" refers to the information or content that the system provides in response to a user's query.

[1002] "Smartphone application" refers to software that runs on a smartphone and is an application developed to provide specific functions or services.

[1003] "Policy change" refers to the modification of existing policies or the introduction of new policies by the government or parliament.

[1004] "Legal amendment" refers to the revision of existing laws and regulations, adding or amending new provisions or rules.

[1005] "Online shopping site operator" refers to an individual or company that manages and operates a website that sells products and services over the Internet.

[1006] The present invention is a system that uses a server, a user terminal, and a generative model to collect and analyze political information and provide it to users in an easy-to-understand manner. Specific embodiments of this system are described below.

[1007] System Overview

[1008] This system consists of a server that collects political information from official government and parliamentary websites and analyzes and preprocesses the data, a generative model that accepts queries from users and provides answers, and a user terminal with an interface for users to input queries.

[1009] Server Features

[1010] Data collection

[1011] The server periodically collects political information. To do this, it uses APIs and web scraping technology to obtain data from official government websites and meeting minutes databases. Specific methods include using libraries such as "BeautifulSoup" and "Scrapy."

[1012] Data analysis and preprocessing

[1013] The collected political information is analyzed and preprocessed on the server using natural language processing technologies such as spaCy and NLTK, which tokenize, normalize, and remove stop words from the data, making it suitable for training.

[1014] Training a generative model

[1015] The server uses the preprocessed data to train a generative model, which is designed to generate appropriate answers to user queries using artificial intelligence techniques. The training process uses a large dataset and optimizes the model by dividing the dataset into training and validation.

[1016] Query Processing and Answer Generation

[1017] When a user sends a query to the server, the server inputs the query into the generative model, which generates an appropriate answer for the question and returns the result to the server, which formats the answer and sends it to the user's device.

[1018] User device functions

[1019] Question Interface

[1020] The user terminal provides a question interface where the user can enter a query. Specifically, by entering a question in a text box and pressing the "Submit" button, the query is sent to the server. This is done using technologies such as "HTML / CSS" and "React Native."

[1021] Communicating with the Server

[1022] When a user submits a query, the user device sends the query in JSON format to the server using an HTTP POST request. After receiving a response from the server, the user device parses the response and displays it to the user.

[1023] Specific examples

[1024] For example, a user might enter a question into a smartphone application, such as "Please tell me about the new import regulations." The server receives this query and inputs it into a generative model. The generative model generates an appropriate answer based on the collected political information and returns it to the server. The server formats the answer and sends it to the user's device. The user's device displays this answer, and the user can obtain information such as, "Regarding recent import regulations, new tariff rates have been set to protect domestic producers. Specifically, standards for food additives and cosmetics have been tightened, which has resulted in an increase in inspection procedures."

[1025] Example prompt sentence:

[1026] "Please tell me about the new import regulations."

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

[1028] Step 1: Data collection

[1029] The server periodically collects political information. Specifically, it uses APIs and web scraping technology to obtain campaign promises and parliamentary responses from official government websites and meeting minutes databases. Libraries such as "BeautifulSoup" and "Scrapy" are used for this process. The input is the website URL or API endpoint, and the output is the text data of the obtained political information.

[1030] Step 2: Data analysis and preprocessing

[1031] The collected text data is analyzed and preprocessed on the server. Specifically, natural language processing techniques are used to tokenize, normalize, and remove stop words from the data. For this purpose, "spaCy" and "NLTK" are used. The input is text data, and the output is preprocessed token data.

[1032] Step 3: Training the generative model

[1033] The server uses the preprocessed token data to train a generative model. This generative model is designed to generate appropriate answers to user queries. A natural language generation model such as GPT-2 is used to train the generative model. The input is the preprocessed token data, and the output is the trained model.

[1034] Step 4: Receiving a user query

[1035] A user accesses a smartphone application, inputs a query into the question interface, for example, "Please tell me about the new import regulations," and presses the submit button. The input is the user's query, and the output is the query data sent to the server.

[1036] Step 5: Query processing and answer generation

[1037] When the server receives a query from a user, it inputs the query into the generative model, which generates an appropriate answer based on the query and returns the result to the server. The input is the user's query, and the output is the generated answer data.

[1038] Step 6: Format and submit your response

[1039] The server formats the answer returned by the generative model into an easy-to-understand format, and then sends the answer to the user's device. The input is the generated answer data, and the output is the formatted answer.

[1040] Step 7: Display the answer to the user

[1041] The user terminal receives the formatted answer sent from the server and displays it to the user. The user can check the answer displayed on the terminal and obtain the necessary information. The input is the formatted answer from the server, and the output is the information displayed on the user's display.

[1042] Example prompt sentence:

[1043] "Please tell me about the new import regulations."

[1044] The above is an explanation of each processing step of this system and its specific operation.

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

[1046] The present invention is a system that collects and analyzes political information, provides it to users in an easy-to-understand manner, and combines it with an emotion engine that recognizes the user's emotions. Specific embodiments of this system are described below.

[1047] System Overview

[1048] This system includes a server, a user terminal, a generative model, and an emotion engine. The server collects and analyzes political information, and the generative model uses the collected information to generate appropriate answers to user queries. The emotion engine recognizes the emotion of the user when entering a query and adjusts the content of the answer accordingly. The user terminal provides an interface for users to access the system and enter queries.

[1049] Server Features

[1050] Data collection

[1051] The server periodically collects political information from official government websites and parliamentary record databases. Specifically, it uses APIs and web scraping technology to obtain information on campaign promises and parliamentary responses. This collection process is achieved using libraries such as "BeautifulSoup" and "Scrapy." The collected information is then stored in a database.

[1052] Data analysis and preprocessing

[1053] The collected information is parsed and preprocessed on the server using natural language processing techniques (e.g., NLTK or spaCy) to tokenize, normalize, remove stop words, etc. The preprocessed data is then prepared as a training dataset for the generative model.

[1054] Training a generative model

[1055] The server uses the preprocessed data to train a generative model. The generative model uses natural language processing techniques to learn to generate appropriate answers to user queries. During the training process, the dataset is divided into training data and validation data, and the model parameters are optimized. After training is complete, the generative model is able to generate appropriate answers to user queries.

[1056] Query Processing and Answer Generation

[1057] When a user submits a query, the server receives the query and inputs it into the generative model. The emotion engine simultaneously analyzes the user's emotion when submitting the query and provides that information to the generative model. The generative model generates a response based on the query and emotion information and returns the result to the server. The server then formats the response and sends it to the user's device.

[1058] Emotion Engine Functions

[1059] Emotion analysis

[1060] The emotion engine analyzes the emotions expressed when a user enters a query. Analysis methods include emotion recognition from text input, emotion recognition from voice input, and even emotion recognition by analyzing the user's facial image. Using technologies such as "Emotion Recognition API" and "Facial Expression Recognition API," the engine can analyze user emotions with high accuracy.

[1061] User device functions

[1062] Question Interface

[1063] The user terminal provides a question interface where the user can enter a query. The user enters a question in a text box and presses the "Submit" button to send the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[1064] Communicating with the Server

[1065] When a user submits a question, the user device sends the question in JSON format to the server using an HTTP POST request. Upon receiving the response from the server, the user device parses it and displays it to the user.

[1066] User operations

[1067] Launching the app

[1068] The user launches the application on their device.

[1069] Enter a question

[1070] The user enters their question into the question interface and presses the "Submit" button. For example, they might enter, "What is the current discussion about the consumption tax increase?"

[1071] Confirm answer

[1072] The user checks the response from the server displayed on the device. For example, it might say, "Recent discussions in the Diet about the consumption tax increase have focused on the burden on living expenses and the impact on small and medium-sized businesses." The emotion engine also analyzes the user's emotions and adjusts the response accordingly, allowing the user to obtain information in a format that is easier to understand.

[1073] Through the above-described embodiment, users can easily obtain political information that interests them, and the information can be provided in an appropriate format through sentiment analysis. By combining a generative model and a sentiment engine, it is possible to improve the quality of responses to users and enhance the user experience.

[1074] The processing flow will be explained below.

[1075] Step 1: The server gathers political information

[1076] The server accesses the government's official website and meeting minutes database, and collects information on public pledges and parliamentary responses using APIs and web scraping technology.

[1077] Specifically, it uses libraries such as "BeautifulSoup" and "Scrapy" to extract the necessary information from web pages.

[1078] The collected information is stored in a database.

[1079] Step 2: The server parses and preprocesses the data

[1080] The server tokenizes the collected political information and analyzes it using natural language processing (NLP) techniques.

[1081] We use NLP libraries such as "NLTK" and "spaCy" to preprocess the data by tokenizing, normalizing, and removing stop words.

[1082] The preprocessed data is prepared as a training dataset for a generative model.

[1083] Step 3: The server trains the generative model

[1084] The server uses the preprocessed data to train a generative model (e.g., GPT-4).

[1085] In the training process, the dataset is divided into training data and validation data, and the parameters of the generative model are optimized.

[1086] Once trained, the generative model is able to generate appropriate answers to user queries.

[1087] Step 4: The server deploys the generative model

[1088] The server deploys the trained generative model as an API, making it accessible from outside.

[1089] Set up a Restful API or GraphQL API and set up an endpoint to receive queries from users.

[1090] Step 5: User enters and submits question

[1091] The terminal displays an interface for the user to enter a question.

[1092] The user enters a question of interest and presses the "Submit" button. For example, "What is the current discussion about the consumption tax increase?"

[1093] Step 6: The device sends the question to the server

[1094] When a user submits a question, the device sends the question in JSON format to the server.

[1095] Send your question to the server's API endpoint using an HTTP POST request.

[1096] Step 7: The server receives the question and inputs it into the emotion engine

[1097] The server inputs the question received from the user into the emotion engine.

[1098] The emotion engine analyzes the question content and the context of the user's input to recognize their emotional state.

[1099] Step 8: The emotion engine provides emotion information to the generative model

[1100] The emotion engine provides the recognized emotion information to the generative model.

[1101] The generative model generates answers with appropriate tone and content based on emotional information.

[1102] Step 9: The server receives and formats the generative model's answer

[1103] The server parses the answers received from the generative model and formats them as needed for display to the user.

[1104] Step 10: The server sends the formatted response to the device

[1105] The server sends the formatted response to the user terminal.

[1106] The answer is returned to the device as an HTTP response.

[1107] Step 11: The device displays the response from the server.

[1108] The terminal parses the response received from the server and displays it in a user-friendly format.

[1109] Users can check the displayed answers and get answers to their questions. For example, they might see something like, "Recent discussions in the Diet about the consumption tax increase have focused on the cost of living and the impact on small and medium-sized businesses." Furthermore, the emotion engine provides information in a tone that reflects the user's emotions, making it easier for users to understand.

[1110] Example 2

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

[1112] Conventional political information gathering systems have had difficulty efficiently collecting, analyzing, and providing information of interest to users in an easy-to-understand format. Furthermore, they were unable to generate appropriate responses that took the user's emotions into account, resulting in a poor user experience. It is necessary to solve this problem.

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

[1114] In this invention, the server includes means for collecting political information, means for analyzing and preprocessing the political information, means for training a data model using the analyzed information, means for receiving queries from users and inputting them into the data model, means for analyzing the user's emotions, and means for transmitting answers generated by adding the emotional information, thereby enabling users to efficiently collect and understand political information and receive responses that take their emotions into consideration.

[1115] "Political information" refers to official document information relating to the government or parliament and the content of parliamentary debates.

[1116] "Analysis" refers to the process of breaking down collected political information and understanding its meaning and structure.

[1117] "Preprocessing" refers to the process of formatting the parsed information into a format that can be used by the data model.

[1118] A "data model" is a model trained using natural language processing techniques to generate appropriate responses based on user queries.

[1119] "Query" refers to a question or request that a user enters into a system to obtain information about their concern.

[1120] "Sentiment analysis" refers to the technology of identifying the sentiment contained in a user's query or input and tailoring responses based on that sentiment.

[1121] "Sending a response" refers to the process of providing the answer generated by the generative model to the user terminal and displaying it to the user.

[1122] The present invention is a system that collects and analyzes political information, provides it to users in an easy-to-understand manner, and combines it with an emotion engine that recognizes the user's emotions. Specific embodiments of this system are described below.

[1123] Server Features

[1124] Data collection

[1125] The server collects political information from official government websites and meeting minutes databases. Specifically, it obtains the information using APIs and web scraping techniques. This processing is achieved using libraries such as "BeautifulSoup" and "Scrapy." The collected information is then stored in a database.

[1126] Data analysis and preprocessing

[1127] The server analyzes and preprocesses the collected information using natural language processing techniques such as NLTK and spaCy. The analysis process includes tokenization, normalization, and stop word removal. The preprocessed data is then prepared as a training dataset for the generative model.

[1128] Training a generative model

[1129] The server uses the preprocessed data to train a generative model. Natural language processing techniques such as Transformer and BERT are used for the generative model. During the training process, the dataset is divided into training data and validation data, and the model parameters are optimized. After training is complete, the generative model is able to generate appropriate answers to user queries.

[1130] Emotion Engine Functions

[1131] Emotion analysis

[1132] The emotion engine analyzes the emotions expressed when a user enters a query. This can be done by recognizing emotions from text input, voice input, or even by analyzing facial images. Using the "Emotion Recognition API" and "Facial Expression Recognition API," it analyzes user emotions with high accuracy.

[1133] User device functions

[1134] Question Interface

[1135] The user terminal provides a question interface where users can enter queries. This interface is built using technologies such as "HTML / CSS" and "React Native." Users can enter a question in the text box and press the "Submit" button to send the query to the server.

[1136] Communicating with the Server

[1137] When a user submits a question, the device sends it to the server in JSON format using an HTTP POST request. Upon receiving a response from the server, the device parses the information and displays it to the user.

[1138] User operations

[1139] A user launches the application on their device and enters "What has been discussed recently about the consumption tax increase?" into the question interface. When the user presses the "Send" button, the query is sent to the server. The server inputs this query into a generative model, and an emotion engine analyzes the user's emotions. The generative model then generates a response based on the query and emotion information and returns it to the server. The server formats the response and sends it to the user's device, where the user can view it. For example, the response may appear as "Recent discussions about the consumption tax increase in the Diet have focused on the burden of living costs and the impact on small and medium-sized businesses."

[1140] Through this system, users can efficiently collect and analyze political information they are interested in and obtain it in an appropriate format. By combining a generative model with an emotion engine, it is possible to improve the quality of responses to users and enhance the user experience.

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

[1142] Step 1:

[1143] The server accesses the government's official website and the minutes database and collects information using APIs and web scraping technology. It uses libraries such as "BeautifulSoup" and "Scrapy" to analyze web pages and obtain information on campaign promises and parliamentary responses. The input is the government's official website and the minutes database, and the output is a dataset of collected political information.

[1144] Step 2:

[1145] The server stores the collected political information in a database. Specifically, it formats the information into an appropriate format and stores it in the database. This database uses "MySQL" or "PostgreSQL." The input is the collected political information, and the output is the data stored in the database.

[1146] Step 3:

[1147] The server retrieves the collected data from the database and performs natural language processing using NLTK and spaCy. Here, the data is tokenized, normalized, and stop words are removed. The input is political information retrieved from the database, and the output is the preprocessed data.

[1148] Step 4:

[1149] The server uses the preprocessed data as a training dataset for a generative model. It trains the data model using natural language processing techniques such as Transformer and BERT. During the training process, the dataset is split into training data and validation data, and the model parameters are optimized. The input is the preprocessed data, and the output is a trained generative model.

[1150] Step 5:

[1151] A user starts the application on their device and inputs a query into the question interface. For example, they input, "What is the current discussion about the consumption tax increase?" The input is the query from the user, and the output is the transmission of the query by the device.

[1152] Step 6:

[1153] The terminal converts the query entered by the user into JSON format and sends it to the server via an HTTP POST request. The input is the query from the user, and the output is the request sent to the server.

[1154] Step 7:

[1155] The server receives a user query and inputs the received query into the generative model. The input is the query sent from the terminal, and the output is the query input to the generative model.

[1156] Step 8:

[1157] The emotion engine analyzes the emotion of the user when they enter a query. This is done using text analysis or speech analysis. For example, it uses the Emotion Recognition API or Facial Expression Recognition API. The input is the user's query, and the output is the analyzed emotion information.

[1158] Step 9:

[1159] Based on the emotion information provided by the emotion engine, the generative model generates a response to the query. The input is the query and emotion information, and the output is the response result. For example, the generated response might be, "Recent discussions in the Diet about the consumption tax increase have focused on the burden of living expenses and the impact on small and medium-sized businesses."

[1160] Step 10:

[1161] The server formats the response results obtained from the generative model. It formats the results into an appropriate format and sends them to the user's device. The input is the response results from the generative model, and the output is the response formatted for sending to the device.

[1162] Step 11:

[1163] The device receives the response from the server, parses it from JSON format, and displays it in a user-friendly format based on that information. The input is the formatted response, and the output is the response that is displayed to the user. For example, it might say, "Recent discussions in the Diet about raising the consumption tax have focused on the cost of living and the impact on small and medium-sized businesses."

[1164] (Application example 2)

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

[1166] In today's information society, it is important to quickly and accurately collect political and product information and provide it to users in an easy-to-understand manner. However, conventional systems have difficulty analyzing user emotions and adjusting responses accordingly, resulting in a poor user experience. Furthermore, in brick-and-mortar stores, there is a similar lack of support that reflects user emotions, making it difficult to improve customer satisfaction.

[1167] The identification processing 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 collecting political information, means for analyzing and preprocessing the collected political information, means for training a generative model using the analyzed information, means for receiving a query from a user and inputting it into the generative model, means for receiving and sending the generative model's response to the user's query, means for analyzing the user's emotion at the time of query input, means for adjusting the generated response based on the emotion analysis result, means for collecting and analyzing product information in a physical store, means for receiving a user's query regarding product information in the physical store and providing an answer, and means for adjusting customer service based on the emotion analysis result. This makes it possible to provide responses that reflect the user's emotion and adjust customer service in a physical store in real time.

[1168] "Political information" refers to data related to public policies, such as campaign promises and parliamentary responses provided by the government and parliament.

[1169] A "generative model" is an algorithm that is trained using natural language processing techniques to generate appropriate answers to user queries.

[1170] "Sentiment analysis" is the process of identifying emotions from a user's text or voice input.

[1171] A "query" is a question or request that a user enters into a system.

[1172] A "brick and mortar store" is a commercial establishment that exists in a physical location and offers goods and services.

[1173] The "emotion engine" is a system component that analyzes the user's emotions and adjusts responses accordingly.

[1174] "Product information" refers to data about the features and specifications of products sold in physical stores.

[1175] A "user terminal" is an electronic device used by a user to access the system and enter queries.

[1176] "Data collection" refers to the process of obtaining necessary information from official government websites, meeting minutes databases, etc.

[1177] "Natural language processing technology" is an artificial intelligence technology for understanding and processing human language.

[1178] An "HTTP POST request" is one of the communication protocols for sending data to a web server.

[1179] "Analysis" is the process of processing and formatting collected data.

[1180] "Preprocessing" refers to operations such as tokenizing, normalizing, and removing stop words from data prior to data analysis.

[1181] A "generated answer" is a response provided by a generative model to a user's query.

[1182] A "training dataset" is a collection of data used to train a generative model.

[1183] This invention is a system that collects and analyzes political and product information, recognizes user emotions, and adjusts responses. This system includes a server, a user terminal, a generative model, and an emotion engine.

[1184] Server Features

[1185] 1. Data collection: The server periodically collects political information from official government websites and parliamentary record databases. Using APIs and web scraping technology, it retrieves information on campaign promises and parliamentary responses and stores the information in a database. Specifically, it uses libraries such as "BeautifulSoup" and "Scrapy."

[1186] 2. Data analysis and preprocessing: The collected information is parsed and preprocessed on the server. Natural language processing techniques (e.g., spaCy or NLTK) are used to tokenize, normalize, and remove stop words from the data. The preprocessed data is then prepared as a training dataset for the generative model.

[1187] 3. Training the generative model: The server uses the preprocessed data to train the generative model, which uses natural language processing techniques to learn to generate appropriate answers to user queries.

[1188] 4. Query processing and answer generation: When a user submits a query, the server receives the query and inputs it into the generative model. At the same time, the emotion engine analyzes the user's emotion when submitting the query and provides that information to the generative model. The generative model generates a response based on the query and emotion information and returns the result to the server. The server then formats the response and sends it to the user's device.

[1189] Emotion Engine Functions

[1190] 1. Emotion Analysis: The emotion engine analyzes the emotions expressed when a user enters a query. It recognizes emotions from text input, voice input, and even by analyzing the user's facial image. Specific technologies used include the "Emotion Recognition API" and "Facial Expression Recognition API."

[1191] User device functions

[1192] 1. Question interface: The user device provides an interface where the user can enter a query. The user enters a question in the text box and presses the submit button, which sends the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[1193] 2. Communication with the server: When a user submits a question, the user device sends the question in JSON format to the server using an HTTP POST request. Upon receiving the response from the server, the user device parses it and displays it to the user.

[1194] Product information gathering and query response in physical stores

[1195] 1. Product information collection: The server collects and analyzes product information sold in physical stores. This function obtains information from physical store databases and public product catalogs.

[1196] 2. Query answering and sentiment analysis: When a user enters a product question in a physical store, the question is sent to the server, and the generative model generates an appropriate answer. At the same time, the sentiment engine analyzes the user's sentiment and adjusts the answer accordingly.

[1197] Usage example

[1198] If a user opens a smartphone app and types the question, "What is the battery life of my smartphone?", the server receives the query, the emotion engine analyzes the user's emotion as "neutral," the generative model generates an appropriate answer, and the response, "The latest smartphones feature fast processing and high-quality cameras," is sent to the user's device.

[1199] Prompt Sentence Examples

[1200] If a user asks "What are the features of the latest smartphones?" and sentiment analysis detects "joy,"

[1201] "We're glad you enjoyed it! The latest smartphones feature fast processing and high-quality cameras," the response provided reads.

[1202] This system improves the user experience by providing answers that reflect the user's feelings.

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

[1204] Step 1:

[1205] The user enters a query into the question interface on the terminal and presses the "Submit" button. The input is the user query text, which is the question or information the user wants to know. The terminal converts this text into JSON format and sends it to the server using an HTTP POST request. The input data is the user query (e.g., "What is the battery life of my smartphone?"), and the output is the JSON data that is sent to the server.

[1206] Step 2:

[1207] The server receives queries from the device and analyzes the query contents. The input is JSON data sent from the device, and natural language processing techniques are used for analysis. The server tokenizes the query using libraries such as "spaCy" and "NLTK" and extracts the necessary information. Data processing involves tokenization, normalization, and extraction of the necessary information, and the analyzed query data is obtained as output.

[1208] Step 3:

[1209] The server inputs the parsed query data into the generative model. This input data is the parsed query data. The generative model uses a pre-trained natural language processing algorithm to generate the optimal answer to the query. The output is the answer text generated by the generative model. Specifically, the generative model generates appropriate information from the query and generates data.

[1210] Step 4:

[1211] The server uses an emotion engine to analyze the user's emotion when inputting. The input requires the user's query text, and emotion recognition uses technologies such as the "Emotion Recognition API" and "Facial Expression Recognition API." The emotion engine analyzes the query text and identifies the user's emotion. Specifically, it extracts emotion labels from the text. The output is the emotion analysis result (e.g., "neutral," "joy," "anger," etc.).

[1212] Step 5:

[1213] The server combines the answer from the generative model with the emotion analysis results from the emotion engine. The input data required is the answer text and emotion label. The server adjusts the generated answer based on the emotion label and returns the optimal answer to the user. Data processing involves adjusting the response message according to the emotion label. The adjusted final answer text is obtained as the output.

[1214] Step 6:

[1215] The server formats the final answer text and sends it to the user's device. The input is the adjusted final answer text, which is then processed into a format that the user's device can understand. The specific operation is to send a response in JSON format via an HTTP POST request. The output is the final answer data sent to the user's device.

[1216] Step 7:

[1217] The user device receives the final response data from the server and displays it on the user interface. The input is the JSON data of the final response sent from the server, which is parsed and converted into a text format that the user can understand. The specific operation is to display the response content on an interface built with HTML / CSS or React Native. The output is the answer text that is displayed to the user.

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

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

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

[1221] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1235] The present invention is a system for collecting and analyzing political information and providing it to users in an easily understandable manner. A specific embodiment of this system will be described below.

[1236] System Overview

[1237] This system includes a server, a user terminal, and a generative model. The server collects and analyzes political information, and the generative model uses the collected information to generate appropriate answers to user queries. The user terminal provides an interface for users to access the system and input queries.

[1238] Server Features

[1239] Data collection

[1240] The server periodically collects political information from official government websites and parliamentary record databases. Specifically, it uses APIs and web scraping technology to obtain information on campaign promises and parliamentary responses. This collection process is achieved using libraries such as "BeautifulSoup" and "Scrapy."

[1241] Data analysis and preprocessing

[1242] The collected information is parsed and preprocessed on the server using natural language processing techniques (e.g., NLTK or spaCy) to tokenize, normalize, remove stop words, etc. The preprocessed data is then used as a training dataset for the generative model.

[1243] Training a generative model

[1244] The server uses the preprocessed data to train a generative model, which uses natural language processing techniques to learn to generate appropriate answers to user queries. During the training process, the dataset is divided into training data and validation data, and the model parameters are optimized.

[1245] Query Processing and Answer Generation

[1246] When a user submits a query, the server receives the query and inputs it into the generative model. The generative model generates a response to the query and returns the result to the server. The server then formats the response and sends it to the user's device.

[1247] User device functions

[1248] Question Interface

[1249] The user terminal provides a question interface where the user can enter a query. The user enters a question in a text box and presses the "Submit" button to send the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[1250] Communicating with the Server

[1251] When a user submits a question, the user device sends the question in JSON format to the server using an HTTP POST request. Upon receiving the response from the server, the user device parses it and displays it to the user.

[1252] User operations

[1253] Launching the app

[1254] The user launches the application on their device.

[1255] Enter a question

[1256] The user enters their question into the question interface and presses the "Submit" button. For example, they might enter, "What is the current discussion about the consumption tax increase?"

[1257] Confirm answer

[1258] The user checks the response from the server displayed on the device. For example, the response may read, "Recent discussions in the Diet about raising the consumption tax have focused on the burden on living expenses and the impact on small and medium-sized businesses."

[1259] Through the above-described embodiment, users can easily obtain political information that they are interested in. Furthermore, by using a generative model, it becomes possible to provide complex information in an easy-to-understand manner.

[1260] The processing flow will be explained below.

[1261] Step 1: The server gathers political information

[1262] The server accesses the government's official website and meeting minutes database, and collects information on public pledges and parliamentary responses using APIs and web scraping technology.

[1263] Specifically, it uses libraries such as "BeautifulSoup" and "Scrapy" to extract the necessary information from web pages.

[1264] The collected information is stored in a database.

[1265] Step 2: The server parses and preprocesses the data

[1266] The server tokenizes the collected political information and analyzes it using natural language processing (NLP) techniques.

[1267] We use NLP libraries such as "NLTK" and "spaCy" to preprocess the data by tokenizing, normalizing, and removing stop words.

[1268] The preprocessed data is prepared as a training dataset for a generative model.

[1269] Step 3: The server trains the generative model

[1270] The server uses the preprocessed data to train a generative model (e.g., GPT-4).

[1271] In the training process, the dataset is divided into training data and validation data, and the parameters of the generative model are optimized.

[1272] Once trained, the generative model is able to generate appropriate answers to user queries.

[1273] Step 4: The server deploys the generative model

[1274] The server deploys the trained generative model as an API, making it accessible from outside.

[1275] Set up a Restful API or GraphQL API and set up an endpoint to receive queries from users.

[1276] Step 5: User enters and submits question

[1277] The terminal displays an interface for the user to enter a question.

[1278] The user enters a question of interest and presses the "Submit" button. For example, "What is the current discussion about the consumption tax increase?"

[1279] Step 6: The device sends the question to the server

[1280] When a user submits a question, the device sends the question in JSON format to the server.

[1281] Send your question to the server's API endpoint using an HTTP POST request.

[1282] Step 7: The server receives the question and inputs it into the generative model

[1283] The server inputs questions received from users into the generative model.

[1284] A generative model generates appropriate answers to questions.

[1285] Step 8: The server receives and formats the generative model's answer

[1286] The server parses the answers received from the generative model and formats them as needed for display to the user.

[1287] Step 9: The server sends the formatted response to the device

[1288] The server sends the formatted response to the user terminal.

[1289] The answer is returned to the device as an HTTP response.

[1290] Step 10: The device displays the response from the server.

[1291] The terminal parses the response received from the server and displays it in a user-friendly format.

[1292] Users can check the displayed answers and get the answer to their question. For example, they might see something like, "Recent discussions in the Diet about raising the consumption tax have focused on the cost of living and the impact on small and medium-sized businesses."

[1293] Example 1

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

[1295] Conventional systems for collecting and analyzing political information collect information infrequently, making it difficult for users to instantly obtain the latest political information. Furthermore, the collected information was not pre-processed or analyzed efficiently, resulting in low accuracy of responses to users. Furthermore, there were issues with the usability of the user interface, making it difficult to input appropriate queries.

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

[1297] In this invention, the server includes means for periodically collecting political information, means for analyzing and preprocessing the collected political information using natural language processing technology, and means for training a generative model using the analyzed information, thereby enabling users to quickly and accurately obtain the latest political information.

[1298] "Political information" refers to information related to political decision-making and policies, such as government and parliamentary pledges and parliamentary responses.

[1299] A "generative model" is an algorithm or method that is trained using natural language processing techniques to generate appropriate answers to user queries.

[1300] "Natural language processing technology" is a technology that enables computers to understand, analyze, and generate natural language that humans use on a daily basis, and involves a wide range of processing including tokenization, normalization, and removal of stop words.

[1301] A "query" is a question or inquiry that a user enters to obtain desired information.

[1302] A "user terminal" is a device that a user uses to access and operate the system, and includes smartphones, tablets, personal computers, etc.

[1303] "JSON format" is an abbreviation for JavaScript Object Notation, and is a text format for structuring and representing data.

[1304] An "HTTP POST request" is a request method that uses the Hypertext Transfer Protocol to send data to a server, and is primarily used to send form data or upload files.

[1305] "Web scraping technology" is a method for automatically extracting and collecting information from websites, and is implemented using programming languages ​​and libraries.

[1306] A "question interface" is a UI (user interface) component that provides a screen and operating environment for users to input and submit queries, and includes a text box and a submit button.

[1307] MODE FOR CARRYING OUT THE INVENTION

[1308] The present invention provides a system for collecting and analyzing political information and providing it to users in an easily understandable manner. This system includes a server, a user terminal, and a generative model. Specific embodiments of this system are described below.

[1309] Server Features

[1310] 1. Data Collection

[1311] The server periodically collects political information from official government websites and parliamentary record databases. Specifically, it uses APIs and web scraping technology to obtain information on campaign promises and parliamentary responses. This collection process is carried out using web scraping libraries such as "BeautifulSoup" and "Scrapy."

[1312] 2. Data analysis and preprocessing

[1313] The collected information is analyzed and preprocessed on the server. This analysis uses natural language processing technologies such as "NLTK" and "spaCy" to tokenize, normalize, and remove stop words from the data. For example, minutes data is broken down into sentences such as "The consumption tax increase is being discussed in the Diet in relation to the cost of living," and important keywords are extracted.

[1314] 3. Training the generative model

[1315] The server uses the preprocessed data to train a generative model. This generative model uses natural language processing techniques to learn to generate appropriate answers to user queries. The server divides the dataset into training data and validation data, trains the model, and finds the optimal parameters. This process uses machine learning frameworks such as TensorFlow and PyTorch.

[1316] 4. Answer generation

[1317] When a user submits a query, the server inputs the query into the generative model. The generative model generates a response to the query and returns the result to the server. The server formats the response and sends it to the user's device. For example, if the query was "What is the current discussion about the consumption tax increase?", the model would generate a response such as "The current discussion about the consumption tax increase in the Diet has focused on the burden of living expenses and the impact on small and medium-sized businesses."

[1318] User device functions

[1319] 1. Question Interface

[1320] The user terminal provides a question interface where the user can enter a query. The user enters a question in a text box and presses the "Submit" button to send the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[1321] 2. Communication with the server

[1322] When a user submits a question, the device converts the question into JSON format and sends it to the server as an HTTP POST request using the axios library. Upon receiving the response from the server, the device parses it and displays it to the user.

[1323] User operations

[1324] 1. Launch the app

[1325] A user launches an application on their device, which can be a smartphone, tablet, personal computer, or other device.

[1326] 2. Enter your question

[1327] Users enter their questions into the question interface and press the "Submit" button. Examples of questions include "What's the latest on recent environmental policy?" or "What are the talking points regarding health care reform?"

[1328] 3. Confirm answer

[1329] The user checks the response from the server displayed on the device. For example, a response such as "The latest information on environmental policy is that the main measures currently being implemented are ____" is displayed, and the user can check the details.

[1330] Through the above-described embodiment, users can easily obtain political information that interests them. Furthermore, by using a generative model, it becomes possible to provide complex information in an easy-to-understand manner. This system allows for the prompt provision of the latest political information, improving the reliability of the information and the ease of use of the user interface.

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

[1332] System processing steps

[1333] Server Processing Steps

[1334] Step 1: Data collection

[1335] Description: The server periodically collects political information, specifically using web scraping techniques and APIs to retrieve information from official government websites and parliamentary record databases.

[1336] Input: Official government website URL, API endpoint

[1337] Output: Political information (campaign promises, parliamentary responses, etc.)

[1338] What it does: It uses BeautifulSoup to parse information from websites and Scrapy to crawl web pages.

[1339] Step 2: Data analysis and preprocessing

[1340] Description: Analyzes and pre-processes collected political information, using natural language processing techniques like NLTK and spaCy to tokenize, normalize, and remove stop words from the data.

[1341] Input: Collected political information (text data)

[1342] Output: Preprocessed text data (tokenized, normalized, and stopword-removed)

[1343] Specific operation: The server uses "spaCy" to tokenize sentences and remove unnecessary words. For example, minutes data is converted into the format "The consumption tax increase is being discussed in the Diet in relation to the burden of living expenses."

[1344] Step 3: Training the generative model

[1345] Description: Train a generative model using preprocessed data. Split the dataset into training and validation data and optimize the model parameters.

[1346] Input: Preprocessed text data

[1347] Output: A trained generative model

[1348] How it works: The server trains the model using the TensorFlow or PyTorch framework, splitting the dataset into 80% for training and 20% for validation.

[1349] Step 4: Answer Generation

[1350] Description: When a user submits a query, the server inputs the query into the generative model and sends the answer generated by the model to the user's device.

[1351] Input: User query

[1352] Output: The answer from the generative model

[1353] How it works: The server receives a user query, inputs it into the model, and generates a response. For example, in response to the query "What has the recent discussion been about regarding the consumption tax increase?", the server generates the answer "The recent discussion about the consumption tax increase in the Diet has focused on the burden of living expenses and the impact on small and medium-sized businesses."

[1354] ---

[1355] User terminal processing steps

[1356] Step 5: Displaying the Question Interface

[1357] Description: The user terminal provides a question interface where the user can enter a query. The user enters the question here and presses the submit button.

[1358] Input: User Interface

[1359] Output: User query

[1360] Specific behavior: The interface is built using "HTML / CSS" and "React Native" and displays a text box and a submit button.

[1361] Step 6: Submit a query

[1362] Description: When a user enters a question and presses the submit button, the user's device converts the question into JSON format and sends an HTTP POST request to the server.

[1363] Input: User query

[1364] Output: Query data in JSON format

[1365] What it does: Uses the "axios" library to send JSON data containing the query to the server.

[1366] Step 7: Communicating with the Server

[1367] Description: The user terminal receives the response from the server, parses it and displays it in the user interface.

[1368] Input: JSON format response data from the server

[1369] Output: The response that is displayed to the user

[1370] Specific behavior: Receives JSON-formatted response data, parses it, and displays it to the user in an appropriate format.

[1371] ---

[1372] User operations

[1373] Step 8: Launch the app

[1374] Description: A user launches an application on their device.

[1375] Input: None

[1376] Output: Application home screen

[1377] Specific behavior: The user taps the app icon on the smartphone's home screen, or opens a web browser and accesses the specified URL.

[1378] Step 9: Enter your question

[1379] Description: The user enters their question into the question interface and presses the "Submit" button.

[1380] Input: User question (prompt)

[1381] Output: Query data sent to the server

[1382] What it does: Type "What's the latest on recent environmental policy?" or "Please explain the talking points on healthcare reform" into the text box and tap the send button.

[1383] Step 10: Check your answers

[1384] Description: The user checks the server's response displayed on the terminal.

[1385] Input: Response data from the server

[1386] Output: The response displayed in the user interface

[1387] Specific operation: The screen will display something like "As the latest information on environmental policy, the main measures currently being implemented are ____," and the user will confirm the details.

[1388] Through the above processing steps, the system can provide political information to users efficiently and quickly.

[1389] (Application example 1)

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

[1391] In modern online shopping site operations, policy changes and legal amendments can directly affect how products are handled and distributed. Therefore, it is necessary to quickly obtain the latest policy information and respond appropriately. However, conventional methods require a great deal of effort to collect and analyze policy information, which often results in delayed responses. There is a need for a method that solves this problem and allows online shopping site operators to efficiently respond to policy and legal amendments.

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

[1393] In this invention, the server includes means for collecting political information, means for analyzing and preprocessing the collected political information, means for training a generative model using the analyzed information, means for receiving queries from users and inputting them into the generative model, means for receiving and transmitting answers from the generative model to the user queries, means for supporting the operator of an online shopping site to respond quickly to policy changes and legal amendments, and a smartphone application that provides policy information in response to questions from users based on the above means, thereby enabling the operator of an online shopping site to efficiently respond to policy changes and legal amendments.

[1394] "Political information" is a concept that includes information related to policies and laws provided by the government or parliament.

[1395] "Analysis" refers to the process of breaking down collected data into an understandable format and processing it.

[1396] "Preprocessing" refers to a series of operations performed to prepare data for easier analysis.

[1397] A "generative model" refers to an algorithm or system that is trained to generate relevant answers to user queries.

[1398] "Query" refers to a question or request that a user enters into a system to obtain information.

[1399] "Answer" refers to the information or content that the system provides in response to a user's query.

[1400] "Smartphone application" refers to software that runs on a smartphone and is an application developed to provide specific functions or services.

[1401] "Policy change" refers to the modification of existing policies or the introduction of new policies by the government or parliament.

[1402] "Legal amendment" refers to the revision of existing laws and regulations, adding or amending new provisions or rules.

[1403] "Online shopping site operator" refers to an individual or company that manages and operates a website that sells products and services over the Internet.

[1404] The present invention is a system that uses a server, a user terminal, and a generative model to collect and analyze political information and provide it to users in an easy-to-understand manner. Specific embodiments of this system are described below.

[1405] System Overview

[1406] This system consists of a server that collects political information from official government and parliamentary websites and analyzes and preprocesses the data, a generative model that accepts queries from users and provides answers, and a user terminal with an interface for users to input queries.

[1407] Server Features

[1408] Data collection

[1409] The server periodically collects political information. To do this, it uses APIs and web scraping technology to obtain data from official government websites and meeting minutes databases. Specific methods include using libraries such as "BeautifulSoup" and "Scrapy."

[1410] Data analysis and preprocessing

[1411] The collected political information is analyzed and preprocessed on the server using natural language processing technologies such as spaCy and NLTK, which tokenize, normalize, and remove stop words from the data, making it suitable for training.

[1412] Training a generative model

[1413] The server uses the preprocessed data to train a generative model, which is designed to generate appropriate answers to user queries using artificial intelligence techniques. The training process uses a large dataset and optimizes the model by dividing the dataset into training and validation.

[1414] Query Processing and Answer Generation

[1415] When a user sends a query to the server, the server inputs the query into the generative model, which generates an appropriate answer for the question and returns the result to the server, which formats the answer and sends it to the user's device.

[1416] User device functions

[1417] Question Interface

[1418] The user terminal provides a question interface where the user can enter a query. Specifically, by entering a question in a text box and pressing the "Submit" button, the query is sent to the server. This is done using technologies such as "HTML / CSS" and "React Native."

[1419] Communicating with the Server

[1420] When a user submits a query, the user device sends the query in JSON format to the server using an HTTP POST request. After receiving a response from the server, the user device parses the response and displays it to the user.

[1421] Specific examples

[1422] For example, a user might enter a question into a smartphone application, such as "Please tell me about the new import regulations." The server receives this query and inputs it into a generative model. The generative model generates an appropriate answer based on the collected political information and returns it to the server. The server formats the answer and sends it to the user's device. The user's device displays this answer, and the user can obtain information such as, "Regarding recent import regulations, new tariff rates have been set to protect domestic producers. Specifically, standards for food additives and cosmetics have been tightened, which has resulted in an increase in inspection procedures."

[1423] Example prompt sentence:

[1424] "Please tell me about the new import regulations."

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

[1426] Step 1: Data collection

[1427] The server periodically collects political information. Specifically, it uses APIs and web scraping technology to obtain campaign promises and parliamentary responses from official government websites and meeting minutes databases. Libraries such as "BeautifulSoup" and "Scrapy" are used for this process. The input is the website URL or API endpoint, and the output is the text data of the obtained political information.

[1428] Step 2: Data analysis and preprocessing

[1429] The collected text data is analyzed and preprocessed on the server. Specifically, natural language processing techniques are used to tokenize, normalize, and remove stop words from the data. For this purpose, "spaCy" and "NLTK" are used. The input is text data, and the output is preprocessed token data.

[1430] Step 3: Training the generative model

[1431] The server uses the preprocessed token data to train a generative model. This generative model is designed to generate appropriate answers to user queries. A natural language generation model such as GPT-2 is used to train the generative model. The input is the preprocessed token data, and the output is the trained model.

[1432] Step 4: Receiving a user query

[1433] A user accesses a smartphone application, inputs a query into the question interface, for example, "Please tell me about the new import regulations," and presses the submit button. The input is the user's query, and the output is the query data sent to the server.

[1434] Step 5: Query processing and answer generation

[1435] When the server receives a query from a user, it inputs the query into the generative model, which generates an appropriate answer based on the query and returns the result to the server. The input is the user's query, and the output is the generated answer data.

[1436] Step 6: Format and submit your response

[1437] The server formats the answer returned by the generative model into an easy-to-understand format, and then sends the answer to the user's device. The input is the generated answer data, and the output is the formatted answer.

[1438] Step 7: Display the answer to the user

[1439] The user terminal receives the formatted answer sent from the server and displays it to the user. The user can check the answer displayed on the terminal and obtain the necessary information. The input is the formatted answer from the server, and the output is the information displayed on the user's display.

[1440] Example prompt sentence:

[1441] "Please tell me about the new import regulations."

[1442] The above is an explanation of each processing step of this system and its specific operation.

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

[1444] The present invention is a system that collects and analyzes political information, provides it to users in an easy-to-understand manner, and combines it with an emotion engine that recognizes the user's emotions. Specific embodiments of this system are described below.

[1445] System Overview

[1446] This system includes a server, a user terminal, a generative model, and an emotion engine. The server collects and analyzes political information, and the generative model uses the collected information to generate appropriate answers to user queries. The emotion engine recognizes the emotion of the user when entering a query and adjusts the content of the answer accordingly. The user terminal provides an interface for users to access the system and enter queries.

[1447] Server Features

[1448] Data collection

[1449] The server periodically collects political information from official government websites and parliamentary record databases. Specifically, it uses APIs and web scraping technology to obtain information on campaign promises and parliamentary responses. This collection process is achieved using libraries such as "BeautifulSoup" and "Scrapy." The collected information is then stored in a database.

[1450] Data analysis and preprocessing

[1451] The collected information is parsed and preprocessed on the server using natural language processing techniques (e.g., NLTK or spaCy) to tokenize, normalize, remove stop words, etc. The preprocessed data is then prepared as a training dataset for the generative model.

[1452] Training a generative model

[1453] The server uses the preprocessed data to train a generative model. The generative model uses natural language processing techniques to learn to generate appropriate answers to user queries. During the training process, the dataset is divided into training data and validation data, and the model parameters are optimized. After training is complete, the generative model is able to generate appropriate answers to user queries.

[1454] Query Processing and Answer Generation

[1455] When a user submits a query, the server receives the query and inputs it into the generative model. The emotion engine simultaneously analyzes the user's emotion when submitting the query and provides that information to the generative model. The generative model generates a response based on the query and emotion information and returns the result to the server. The server then formats the response and sends it to the user's device.

[1456] Emotion Engine Functions

[1457] Emotion analysis

[1458] The emotion engine analyzes the emotions expressed when a user enters a query. Analysis methods include emotion recognition from text input, emotion recognition from voice input, and even emotion recognition by analyzing the user's facial image. Using technologies such as "Emotion Recognition API" and "Facial Expression Recognition API," the engine can analyze user emotions with high accuracy.

[1459] User device functions

[1460] Question Interface

[1461] The user terminal provides a question interface where the user can enter a query. The user enters a question in a text box and presses the "Submit" button to send the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[1462] Communicating with the Server

[1463] When a user submits a question, the user device sends the question in JSON format to the server using an HTTP POST request. Upon receiving the response from the server, the user device parses it and displays it to the user.

[1464] User operations

[1465] Launching the app

[1466] The user launches the application on their device.

[1467] Enter a question

[1468] The user enters their question into the question interface and presses the "Submit" button. For example, they might enter, "What is the current discussion about the consumption tax increase?"

[1469] Confirm answer

[1470] The user checks the response from the server displayed on the device. For example, it might say, "Recent discussions in the Diet about the consumption tax increase have focused on the burden on living expenses and the impact on small and medium-sized businesses." The emotion engine also analyzes the user's emotions and adjusts the response accordingly, allowing the user to obtain information in a format that is easier to understand.

[1471] Through the above-described embodiment, users can easily obtain political information that interests them, and the information can be provided in an appropriate format through sentiment analysis. By combining a generative model and a sentiment engine, it is possible to improve the quality of responses to users and enhance the user experience.

[1472] The processing flow will be explained below.

[1473] Step 1: The server gathers political information

[1474] The server accesses the government's official website and meeting minutes database, and collects information on public pledges and parliamentary responses using APIs and web scraping technology.

[1475] Specifically, it uses libraries such as "BeautifulSoup" and "Scrapy" to extract the necessary information from web pages.

[1476] The collected information is stored in a database.

[1477] Step 2: The server parses and preprocesses the data

[1478] The server tokenizes the collected political information and analyzes it using natural language processing (NLP) techniques.

[1479] We use NLP libraries such as "NLTK" and "spaCy" to preprocess the data by tokenizing, normalizing, and removing stop words.

[1480] The preprocessed data is prepared as a training dataset for a generative model.

[1481] Step 3: The server trains the generative model

[1482] The server uses the preprocessed data to train a generative model (e.g., GPT-4).

[1483] In the training process, the dataset is divided into training data and validation data, and the parameters of the generative model are optimized.

[1484] Once trained, the generative model is able to generate appropriate answers to user queries.

[1485] Step 4: The server deploys the generative model

[1486] The server deploys the trained generative model as an API, making it accessible from outside.

[1487] Set up a Restful API or GraphQL API and set up an endpoint to receive queries from users.

[1488] Step 5: User enters and submits question

[1489] The terminal displays an interface for the user to enter a question.

[1490] The user enters a question of interest and presses the "Submit" button. For example, "What is the current discussion about the consumption tax increase?"

[1491] Step 6: The device sends the question to the server

[1492] When a user submits a question, the device sends the question in JSON format to the server.

[1493] Send your question to the server's API endpoint using an HTTP POST request.

[1494] Step 7: The server receives the question and inputs it into the emotion engine

[1495] The server inputs the question received from the user into the emotion engine.

[1496] The emotion engine analyzes the question content and the context of the user's input to recognize their emotional state.

[1497] Step 8: The emotion engine provides emotion information to the generative model

[1498] The emotion engine provides the recognized emotion information to the generative model.

[1499] The generative model generates answers with appropriate tone and content based on emotional information.

[1500] Step 9: The server receives and formats the generative model's answer

[1501] The server parses the answers received from the generative model and formats them as needed for display to the user.

[1502] Step 10: The server sends the formatted response to the device

[1503] The server sends the formatted response to the user terminal.

[1504] The answer is returned to the device as an HTTP response.

[1505] Step 11: The device displays the response from the server.

[1506] The terminal parses the response received from the server and displays it in a user-friendly format.

[1507] Users can check the displayed answers and get answers to their questions. For example, they might see something like, "Recent discussions in the Diet about the consumption tax increase have focused on the cost of living and the impact on small and medium-sized businesses." Furthermore, the emotion engine provides information in a tone that reflects the user's emotions, making it easier for users to understand.

[1508] Example 2

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

[1510] Conventional political information gathering systems have had difficulty efficiently collecting, analyzing, and providing information of interest to users in an easy-to-understand format. Furthermore, they were unable to generate appropriate responses that took the user's emotions into account, resulting in a poor user experience. It is necessary to solve this problem.

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

[1512] In this invention, the server includes means for collecting political information, means for analyzing and preprocessing the political information, means for training a data model using the analyzed information, means for receiving queries from users and inputting them into the data model, means for analyzing the user's emotions, and means for transmitting answers generated by adding the emotional information, thereby enabling users to efficiently collect and understand political information and receive responses that take their emotions into consideration.

[1513] "Political information" refers to official document information relating to the government or parliament and the content of parliamentary debates.

[1514] "Analysis" refers to the process of breaking down collected political information and understanding its meaning and structure.

[1515] "Preprocessing" refers to the process of formatting the parsed information into a format that can be used by the data model.

[1516] A "data model" is a model trained using natural language processing techniques to generate appropriate responses based on user queries.

[1517] "Query" refers to a question or request that a user enters into a system to obtain information about their concern.

[1518] "Sentiment analysis" refers to the technology of identifying the sentiment contained in a user's query or input and tailoring responses based on that sentiment.

[1519] "Sending a response" refers to the process of providing the answer generated by the generative model to the user terminal and displaying it to the user.

[1520] The present invention is a system that collects and analyzes political information, provides it to users in an easy-to-understand manner, and combines it with an emotion engine that recognizes the user's emotions. Specific embodiments of this system are described below.

[1521] Server Features

[1522] Data collection

[1523] The server collects political information from official government websites and meeting minutes databases. Specifically, it obtains the information using APIs and web scraping techniques. This processing is achieved using libraries such as "BeautifulSoup" and "Scrapy." The collected information is then stored in a database.

[1524] Data analysis and preprocessing

[1525] The server analyzes and preprocesses the collected information using natural language processing techniques such as NLTK and spaCy. The analysis process includes tokenization, normalization, and stop word removal. The preprocessed data is then prepared as a training dataset for the generative model.

[1526] Training a generative model

[1527] The server uses the preprocessed data to train a generative model. Natural language processing techniques such as Transformer and BERT are used for the generative model. During the training process, the dataset is divided into training data and validation data, and the model parameters are optimized. After training is complete, the generative model is able to generate appropriate answers to user queries.

[1528] Emotion Engine Functions

[1529] Emotion analysis

[1530] The emotion engine analyzes the emotions expressed when a user enters a query. This can be done by recognizing emotions from text input, voice input, or even by analyzing facial images. Using the "Emotion Recognition API" and "Facial Expression Recognition API," it analyzes user emotions with high accuracy.

[1531] User device functions

[1532] Question Interface

[1533] The user terminal provides a question interface where users can enter queries. This interface is built using technologies such as "HTML / CSS" and "React Native." Users can enter a question in the text box and press the "Submit" button to send the query to the server.

[1534] Communicating with the Server

[1535] When a user submits a question, the device sends it to the server in JSON format using an HTTP POST request. Upon receiving a response from the server, the device parses the information and displays it to the user.

[1536] User operations

[1537] A user launches the application on their device and enters "What has been discussed recently about the consumption tax increase?" into the question interface. When the user presses the "Send" button, the query is sent to the server. The server inputs this query into a generative model, and an emotion engine analyzes the user's emotions. The generative model then generates a response based on the query and emotion information and returns it to the server. The server formats the response and sends it to the user's device, where the user can view it. For example, the response may appear as "Recent discussions about the consumption tax increase in the Diet have focused on the burden of living costs and the impact on small and medium-sized businesses."

[1538] Through this system, users can efficiently collect and analyze political information they are interested in and obtain it in an appropriate format. By combining a generative model with an emotion engine, it is possible to improve the quality of responses to users and enhance the user experience.

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

[1540] Step 1:

[1541] The server accesses the government's official website and the minutes database and collects information using APIs and web scraping technology. It uses libraries such as "BeautifulSoup" and "Scrapy" to analyze web pages and obtain information on campaign promises and parliamentary responses. The input is the government's official website and the minutes database, and the output is a dataset of collected political information.

[1542] Step 2:

[1543] The server stores the collected political information in a database. Specifically, it formats the information into an appropriate format and stores it in the database. This database uses "MySQL" or "PostgreSQL." The input is the collected political information, and the output is the data stored in the database.

[1544] Step 3:

[1545] The server retrieves the collected data from the database and performs natural language processing using NLTK and spaCy. Here, the data is tokenized, normalized, and stop words are removed. The input is political information retrieved from the database, and the output is the preprocessed data.

[1546] Step 4:

[1547] The server uses the preprocessed data as a training dataset for a generative model. It trains the data model using natural language processing techniques such as Transformer and BERT. During the training process, the dataset is split into training data and validation data, and the model parameters are optimized. The input is the preprocessed data, and the output is a trained generative model.

[1548] Step 5:

[1549] A user starts the application on their device and inputs a query into the question interface. For example, they input, "What is the current discussion about the consumption tax increase?" The input is the query from the user, and the output is the transmission of the query by the device.

[1550] Step 6:

[1551] The terminal converts the query entered by the user into JSON format and sends it to the server via an HTTP POST request. The input is the query from the user, and the output is the request sent to the server.

[1552] Step 7:

[1553] The server receives a user query and inputs the received query into the generative model. The input is the query sent from the terminal, and the output is the query input to the generative model.

[1554] Step 8:

[1555] The emotion engine analyzes the emotion of the user when they enter a query. This is done using text analysis or speech analysis. For example, it uses the Emotion Recognition API or Facial Expression Recognition API. The input is the user's query, and the output is the analyzed emotion information.

[1556] Step 9:

[1557] Based on the emotion information provided by the emotion engine, the generative model generates a response to the query. The input is the query and emotion information, and the output is the response result. For example, the generated response might be, "Recent discussions in the Diet about the consumption tax increase have focused on the burden of living expenses and the impact on small and medium-sized businesses."

[1558] Step 10:

[1559] The server formats the response results obtained from the generative model. It formats the results into an appropriate format and sends them to the user's device. The input is the response results from the generative model, and the output is the response formatted for sending to the device.

[1560] Step 11:

[1561] The device receives the response from the server, parses it from JSON format, and displays it in a user-friendly format based on that information. The input is the formatted response, and the output is the response that is displayed to the user. For example, it might say, "Recent discussions in the Diet about raising the consumption tax have focused on the cost of living and the impact on small and medium-sized businesses."

[1562] (Application example 2)

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

[1564] In today's information society, it is important to quickly and accurately collect political and product information and provide it to users in an easy-to-understand manner. However, conventional systems have difficulty analyzing user emotions and adjusting responses accordingly, resulting in a poor user experience. Furthermore, in brick-and-mortar stores, there is a similar lack of support that reflects user emotions, making it difficult to improve customer satisfaction.

[1565] The identification processing 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 collecting political information, means for analyzing and preprocessing the collected political information, means for training a generative model using the analyzed information, means for receiving a query from a user and inputting it into the generative model, means for receiving and sending the generative model's response to the user's query, means for analyzing the user's emotion at the time of query input, means for adjusting the generated response based on the emotion analysis result, means for collecting and analyzing product information in a physical store, means for receiving a user's query regarding product information in the physical store and providing an answer, and means for adjusting customer service based on the emotion analysis result. This makes it possible to provide responses that reflect the user's emotion and adjust customer service in a physical store in real time.

[1566] "Political information" refers to data related to public policies, such as campaign promises and parliamentary responses provided by the government and parliament.

[1567] A "generative model" is an algorithm that is trained using natural language processing techniques to generate appropriate answers to user queries.

[1568] "Sentiment analysis" is the process of identifying emotions from a user's text or voice input.

[1569] A "query" is a question or request that a user enters into a system.

[1570] A "brick and mortar store" is a commercial establishment that exists in a physical location and offers goods and services.

[1571] The "emotion engine" is a system component that analyzes the user's emotions and adjusts responses accordingly.

[1572] "Product information" refers to data about the features and specifications of products sold in physical stores.

[1573] A "user terminal" is an electronic device used by a user to access the system and enter queries.

[1574] "Data collection" refers to the process of obtaining necessary information from official government websites, meeting minutes databases, etc.

[1575] "Natural language processing technology" is an artificial intelligence technology for understanding and processing human language.

[1576] An "HTTP POST request" is one of the communication protocols for sending data to a web server.

[1577] "Analysis" is the process of processing and formatting collected data.

[1578] "Preprocessing" refers to operations such as tokenizing, normalizing, and removing stop words from data prior to data analysis.

[1579] A "generated answer" is a response provided by a generative model to a user's query.

[1580] A "training dataset" is a collection of data used to train a generative model.

[1581] This invention is a system that collects and analyzes political and product information, recognizes user emotions, and adjusts responses. This system includes a server, a user terminal, a generative model, and an emotion engine.

[1582] Server Features

[1583] 1. Data collection: The server periodically collects political information from official government websites and parliamentary record databases. Using APIs and web scraping technology, it retrieves information on campaign promises and parliamentary responses and stores the information in a database. Specifically, it uses libraries such as "BeautifulSoup" and "Scrapy."

[1584] 2. Data analysis and preprocessing: The collected information is parsed and preprocessed on the server. Natural language processing techniques (e.g., spaCy or NLTK) are used to tokenize, normalize, and remove stop words from the data. The preprocessed data is then prepared as a training dataset for the generative model.

[1585] 3. Training the generative model: The server uses the preprocessed data to train the generative model, which uses natural language processing techniques to learn to generate appropriate answers to user queries.

[1586] 4. Query processing and answer generation: When a user submits a query, the server receives the query and inputs it into the generative model. At the same time, the emotion engine analyzes the user's emotion when submitting the query and provides that information to the generative model. The generative model generates a response based on the query and emotion information and returns the result to the server. The server then formats the response and sends it to the user's device.

[1587] Emotion Engine Functions

[1588] 1. Emotion Analysis: The emotion engine analyzes the emotions expressed when a user enters a query. It recognizes emotions from text input, voice input, and even by analyzing the user's facial image. Specific technologies used include the "Emotion Recognition API" and "Facial Expression Recognition API."

[1589] User device functions

[1590] 1. Question interface: The user device provides an interface where the user can enter a query. The user enters a question in the text box and presses the submit button, which sends the query to the server. This interface is built using technologies such as "HTML / CSS" and "React Native."

[1591] 2. Communication with the server: When a user submits a question, the user device sends the question in JSON format to the server using an HTTP POST request. Upon receiving the response from the server, the user device parses it and displays it to the user.

[1592] Product information gathering and query response in physical stores

[1593] 1. Product information collection: The server collects and analyzes product information sold in physical stores. This function obtains information from physical store databases and public product catalogs.

[1594] 2. Query answering and sentiment analysis: When a user enters a product question in a physical store, the question is sent to the server, and the generative model generates an appropriate answer. At the same time, the sentiment engine analyzes the user's sentiment and adjusts the answer accordingly.

[1595] Usage example

[1596] If a user opens a smartphone app and types the question, "What is the battery life of my smartphone?", the server receives the query, the emotion engine analyzes the user's emotion as "neutral," the generative model generates an appropriate answer, and the response, "The latest smartphones feature fast processing and high-quality cameras," is sent to the user's device.

[1597] Prompt Sentence Examples

[1598] If a user asks "What are the features of the latest smartphones?" and sentiment analysis detects "joy,"

[1599] "We're glad you enjoyed it! The latest smartphones feature fast processing and high-quality cameras," the response provided reads.

[1600] This system improves the user experience by providing answers that reflect the user's feelings.

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

[1602] Step 1:

[1603] The user enters a query into the question interface on the terminal and presses the "Submit" button. The input is the user query text, which is the question or information the user wants to know. The terminal converts this text into JSON format and sends it to the server using an HTTP POST request. The input data is the user query (e.g., "What is the battery life of my smartphone?"), and the output is the JSON data that is sent to the server.

[1604] Step 2:

[1605] The server receives queries from the device and analyzes the query contents. The input is JSON data sent from the device, and natural language processing techniques are used for analysis. The server tokenizes the query using libraries such as "spaCy" and "NLTK" and extracts the necessary information. Data processing involves tokenization, normalization, and extraction of the necessary information, and the analyzed query data is obtained as output.

[1606] Step 3:

[1607] The server inputs the parsed query data into the generative model. This input data is the parsed query data. The generative model uses a pre-trained natural language processing algorithm to generate the optimal answer to the query. The output is the answer text generated by the generative model. Specifically, the generative model generates appropriate information from the query and generates data.

[1608] Step 4:

[1609] The server uses an emotion engine to analyze the user's emotion when inputting. The input requires the user's query text, and emotion recognition uses technologies such as the "Emotion Recognition API" and "Facial Expression Recognition API." The emotion engine analyzes the query text and identifies the user's emotion. Specifically, it extracts emotion labels from the text. The output is the emotion analysis result (e.g., "neutral," "joy," "anger," etc.).

[1610] Step 5:

[1611] The server combines the answer from the generative model with the emotion analysis results from the emotion engine. The input data required is the answer text and emotion label. The server adjusts the generated answer based on the emotion label and returns the optimal answer to the user. Data processing involves adjusting the response message according to the emotion label. The adjusted final answer text is obtained as the output.

[1612] Step 6:

[1613] The server formats the final answer text and sends it to the user's device. The input is the adjusted final answer text, which is then processed into a format that the user's device can understand. The specific operation is to send a response in JSON format via an HTTP POST request. The output is the final answer data sent to the user's device.

[1614] Step 7:

[1615] The user device receives the final response data from the server and displays it on the user interface. The input is the JSON data of the final response sent from the server, which is parsed and converted into a text format that the user can understand. The specific operation is to display the response content on an interface built with HTML / CSS or React Native. The output is the answer text that is displayed to the user.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[1637] The following is further disclosed regarding the above embodiment.

[1638] (Claim 1)

[1639] means for gathering political information;

[1640] means for analyzing and preprocessing the collected political information;

[1641] means for training a generative model using the analyzed information;

[1642] means for receiving a query from a user and inputting it into the generative model;

[1643] A system including means for receiving and transmitting generative model answers to user queries.

[1644] (Claim 2)

[1645] 2. The system of claim 1, wherein the political information includes campaign promises and congressional responses.

[1646] (Claim 3)

[1647] 2. The system of claim 1, wherein the generative model is a generative model trained using natural language processing techniques.

[1648] "Example 1"

[1649] (Claim 1)

[1650] means for periodically collecting political information;

[1651] a means for analyzing and preprocessing the collected political information using natural language processing technology;

[1652] means for training a generative model using the analyzed information;

[1653] means for receiving a query from a user and inputting it into the generative model;

[1654] The system includes means for receiving and transmitting to a user terminal an answer generated by the generative model in response to a query.

[1655] (Claim 2)

[1656] 2. The system of claim 1, wherein the political information includes campaign promises and congressional responses.

[1657] (Claim 3)

[1658] 2. The system according to claim 1, wherein the user terminal has a function of converting an input query into a JSON format and transmitting the JSON format by an HTTP POST request.

[1659] (Claim 4)

[1660] The system of claim 1, wherein the generative model is trained using natural language processing techniques and has the ability to format and display the generated answers.

[1661] (Claim 5)

[1662] The system of claim 1, wherein the server uses web scraping technology to collect data from official government websites and meeting minutes databases.

[1663] (Claim 6)

[1664] 2. The system according to claim 1, wherein the user terminal is provided with a means for providing a question interface using HTML / CSS or other web technologies, and for allowing a user to input and submit a query.

[1665] "Application Example 1"

[1666] (Claim 1)

[1667] means for gathering political information;

[1668] means for analyzing and preprocessing the collected political information;

[1669] means for training a generative model using the analyzed information;

[1670] means for receiving a query from a user and inputting it into the generative model;

[1671] 1. A system comprising: means for receiving and transmitting generative model answers to user queries,

[1672] Measures to help online shopping site operators respond quickly to policy changes and legal amendments, and

[1673] A system including a smartphone application that provides policy information in response to questions from a user based on the means.

[1674] (Claim 2)

[1675] 2. The system of claim 1, wherein the political information includes campaign promises and congressional responses.

[1676] (Claim 3)

[1677] 2. The system of claim 1, wherein the generative model is a generative model trained using natural language processing techniques.

[1678] "Example 2: Combining Emotion Engines"

[1679] (Claim 1)

[1680] means for gathering political information;

[1681] means for analyzing and preprocessing the collected political information;

[1682] means for training a data model using the analyzed information;

[1683] means for receiving queries from a user and inputting them into said data model;

[1684] means for analyzing user emotions;

[1685] The system includes a means for transmitting a response generated by adding emotional information.

[1686] (Claim 2)

[1687] 10. The system of claim 1, wherein the political information includes official document information and congressional debates.

[1688] (Claim 3)

[1689] 10. The system of claim 1, wherein the data model is trained using natural language processing techniques.

[1690] "Application example 2 when combining emotion engines"

[1691] (Claim 1)

[1692] means for gathering political information;

[1693] means for analyzing and preprocessing the collected political information;

[1694] means for training a generative model using the analyzed information;

[1695] means for receiving a query from a user and inputting it into the generative model;

[1696] means for receiving and transmitting generative model answers to user queries;

[1697] means for analyzing a user's sentiment when entering a query;

[1698] a means for adjusting the generated response based on the sentiment analysis results;

[1699] A means of collecting and analyzing product information in physical stores,

[1700] means for receiving and providing answers to user queries regarding product information in a physical store;

[1701] A system including a means for adjusting customer responses based on the results of sentiment analysis.

[1702] (Claim 2)

[1703] 2. The system of claim 1, wherein the political information includes campaign promises and congressional responses.

[1704] (Claim 3)

[1705] 2. The system of claim 1, wherein the generative model is a generative model trained using natural language processing techniques, and the emotion analysis analyzes a user's text input using an emotion recognition engine. [Explanation of symbols]

[1706] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. means for gathering political information; means for analyzing and preprocessing the collected political information; means for training a generative model using the analyzed information; means for receiving a query from a user and inputting it into the generative model; A system including means for receiving and transmitting generative model answers to user queries.

2. 2. The system of claim 1, wherein the political information includes campaign promises and congressional responses.

3. The system of claim 1 , wherein the generative model is a generative model trained using natural language processing techniques.

Images