system

Abstract

Provide a system. The method includes: converting terms of use obtained from a service provider into text data; A means for analyzing the converted text data and extracting important parts; A means for generating a summary of the extracted important parts in simple language; A means for selecting particularly important matters from the generated summary sentences and creating a checklist; means for transmitting the generated summary and checklist to a user terminal; A system including:

Description

[Technical Field]

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

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

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

[0004] In today's world, users are required to agree to various terms of use and agreements when using services, but the majority of users often agree without fully understanding the content. This phenomenon increases the risk of inappropriate use and problems occurring because users do not understand the terms. Furthermore, companies must allocate significant resources to responding to user complaints and inquiries, increasing costs. Given this background, there is a demand for a system that allows users to easily understand the terms and conditions and reduces company response costs. [Means for solving the problem]

[0005] To solve the above problems, the present invention comprises the following means. First, a means is provided for converting terms of use obtained from a service provider into text data. Next, a means is provided for analyzing this text data using natural language processing technology and extracting important parts. Based on the analyzed important parts, a means is provided for generating a summary in simple language that is easy for users to understand. Furthermore, a means is provided for selecting particularly important items from the generated summary and creating a checklist. Finally, a means is provided for transmitting the generated summary and checklist to a user terminal. This configuration realizes a system that allows users to easily understand, confirm, and agree to the terms of use, and also reduces response costs for companies.

[0006] "Terms of Use" is a document that describes the terms and conditions of use and restrictions of a service established by a service provider, the obligations and rights of users, and matters related to privacy protection.

[0007] "Text data" refers to character string data extracted from documents such as terms of use, and converted into a format that can be analyzed using natural language processing technology.

[0008] "Natural language processing technology" is a technology that enables computers to understand, interpret, and generate human language, and performs tasks such as analyzing and summarizing text data and extracting keywords.

[0009] "Important parts" are the information contained in the Terms of Use that users are particularly required to understand and that have a significant impact on the use of the service.

[0010] "Plain language" refers to documents that are concise and easy to understand, avoiding technical terms and difficult expressions, so that the general public can easily understand them.

[0011] A "summary" is a short sentence that concisely summarizes a long document or important parts, allowing users to grasp important information in a short amount of time.

[0012] A "checklist" is a list of important matters that users must understand and agree to, with each item marked with a checkbox.

[0013] A "user terminal" is an electronic device, such as a computer, smartphone, or tablet, used by a user to display information sent from the server. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0022] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0035] The present invention provides a system for providing the content of terms of use in a form that is easy for the user to understand and for confirming consent to important items. Specific embodiments for carrying out the present invention will be described below.

[0036] 1. Server-side processing

[0037] Obtaining the regulations and converting them into text data

[0038] The server obtains new terms of service from the service provider (e.g., "Service A Terms of Service.pdf"). These terms are usually in PDF format, and a library (e.g., PyPDF2) is used to convert them into text data.

[0039] Parsing Terms

[0040] The server analyzes the text data using natural language processing (NLP) techniques to identify key sections (e.g., terms of use, privacy, liability, etc.) and extract important keywords using tokenization, importance assessment (e.g., TF-IDF), and summarization techniques (e.g., the BERT model).

[0041] Summary generation

[0042] Based on the key parts of the analysis, the server generates a plain-language summary, which is generated according to pre-defined guidelines and templates and presented in a format that is easy for users to understand.

[0043] Creating a summary checklist

[0044] From the generated summary, particularly important points are selected and a checklist is created. The checklist includes important items that users must agree to (e.g., "You must be 18 years of age or older to use this service").

[0045] Sending data

[0046] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0047] 2. Terminal processing

[0048] Receiving and displaying data

[0049] The terminal receives the summary and checklist sent from the server, analyzes this data, and displays it in a user-friendly format using HTML, CSS, and JavaScript (registered trademark).

[0050] Collecting user responses

[0051] The terminal accepts the user's operation of checking each item on the checklist and pressing the "Agree" button. Information based on this operation is sent to the server.

[0052] Sending data

[0053] The device sends the user's response (checklist and consent history) to the server, which records the user's consent status and helps prevent problems.

[0054] 3. User Operation

[0055] Check the terms and conditions

[0056] The user checks the summary of the terms of use displayed on the device. The summary is concise and easy to understand, allowing the user to understand the content in a short amount of time.

[0057] Check the items

[0058] The user checks each item in the checklist, which lists the most important points in the terms of use and displays them in an easy-to-understand format.

[0059] consent

[0060] The user completes the checklist, checks the necessary items, and then presses the "Agree" button. This operation records that the user has agreed to the terms and conditions.

[0061] Specific examples

[0062] Server-side processing example

[0063] The server retrieves "Service A Terms of Use.pdf" and converts it to text data using the PyPDF2 library. Next, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It then uses the BERT model to generate a summary of the important sections and summarize them in plain text. It then selects important points and creates a checklist. Finally, it sends the summary and checklist to the user's device.

[0064] Example of terminal processing

[0065] The terminal receives the summary and checklist sent from the server, displays them on the screen, accepts the user's checkmarks on the checklist and presses the consent button, and sends the collected response data to the server.

[0066] User operation example

[0067] The user checks the summary displayed on the device, checks the important items, and after checking all the items, presses the "Agree" button to agree to the terms and conditions.

[0068] The processing flow will be explained below.

[0069] Server Processing

[0070] Step 1: Obtaining the terms and converting them to text data

[0071] The server retrieves the new terms of use from the service provider. This is usually a PDF document. The server uses a library (e.g., PyPDF2) to extract the text data from this PDF file.

[0072] Step 2: Preprocessing the text

[0073] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[0074] Step 3: Parsing the Terms

[0075] The server analyzes the preprocessed text using natural language processing (NLP) techniques.

[0076] The server tokenizes the text and splits it into sentences and phrases.

[0077] The server uses importance evaluation techniques such as TF-IDF to extract important keywords and phrases.

[0078] The server uses the BERT model to generate summaries for each important section.

[0079] Step 4: Generate a summary

[0080] The server then converts the summary generated from the analyzed key sections into plain text using pre-defined templates and guidelines, avoiding technical jargon and complex language to make it easier for users to understand.

[0081] Step 5: Create a summary checklist

[0082] The server selects particularly important points from the generated summary and creates a checklist, which contains important items that the user must agree to.

[0083] For example, generate an item in the form "■ You must be 18 years of age or older to use this service."

[0084] Step 6: Send the data

[0085] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0086] Terminal handling

[0087] Step 1: Receiving and displaying data

[0088] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[0089] Step 2: Collect user responses

[0090] The terminal accepts the user's operation of checking each check item, and after the user has confirmed all items, accepts the user's pressing of the "Agree" button.

[0091] Step 3: Send the data

[0092] The terminal sends the user's response (checklist status and consent information) to the server using the HTTP / HTTPS protocol.

[0093] User operations

[0094] Step 1: Review the terms and conditions

[0095] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[0096] Step 2: Check the items

[0097] The user checks each item in the checklist, which lists particularly important matters in the terms of use.

[0098] Step 3: Accept

[0099] The user checks the checklist and checks each item. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[0100] Example 1

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

[0102] In today's world, many users find it difficult to understand the terms of service. Terms of service are usually lengthy and contain many technical terms and legal expressions, making it difficult for the average user to quickly and accurately grasp their content. Furthermore, there is a high risk of trouble or disputes arising due to insufficient confirmation of consent to important terms. There is a need for a system that can solve these issues and enable users to easily understand terms of service and properly consent to important terms.

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

[0104] In this invention, the server includes means for converting the terms of use obtained from the service provider into text data, means for analyzing the converted text data, identifying major sections, and extracting important keywords, means for generating a summary in plain language of the extracted important parts, means for selecting particularly important matters from the generated summary and creating a checklist, and means for transmitting the generated summary and checklist to a user terminal, thereby enabling the user to quickly understand the important contents of the terms of use and appropriately agree to particularly important items.

[0105] A "service provider" is an organization or individual that provides a service to a user.

[0106] "Terms of Use" means the document that sets out the terms, conditions and regulations for use of the Service.

[0107] "Text data" refers to data in which character information is expressed in digital form.

[0108] To "convert" means to change from one form or state to another.

[0109] "Analyzing" means breaking down data or information and clarifying its structure and meaning.

[0110] "Major sections" are parts or sections of a document that are particularly important.

[0111] "Important keywords" are words or phrases that are considered to be particularly important within a document.

[0112] "Simple writing" refers to writing written in simple, easy-to-understand language that is easy for anyone to understand.

[0113] A "summary" is a short sentence that succinctly summarizes the contents of a long document.

[0114] "To select" means to choose from among many things according to a criterion.

[0115] A "checklist" is a list of items to be checked or evaluated.

[0116] A "user terminal" refers to an electronic device such as a computer or smartphone used by a user.

[0117] "Natural language processing technology" refers to technology for processing human language using a computer.

[0118] The "BERT model" refers to a deep learning model transformed from a bidirectional encoder representation.

[0119] The present invention provides a system for providing the content of terms of use in a form that is easy for the user to understand and for confirming consent to important items. Specific embodiments for carrying out the present invention will be described below.

[0120] Server-side processing

[0121] The server first obtains the new terms of use (e.g., "Terms of Use.pdf") from the service provider. These terms are usually in PDF format, and a library (e.g., PyPDF2) is used to convert them into text data. The PyPDF2 library is used to convert the PDF document into text data.

[0122] The server then uses natural language processing (NLP) techniques to analyze the text data. This analysis process identifies major sections (e.g., terms of use, privacy, liability, etc.) and extracts important keywords. Analysis includes tokenization using the NLTK library, importance assessment using TF-IDF, and summarization using the BERT model.

[0123] Based on the analyzed important parts, the server generates a summary in plain language. This summary is generated according to pre-defined guidelines and templates and is provided in a format that is easy for the user to understand. Furthermore, it selects particularly important points from the generated summary and creates a checklist. The checklist contains important items that the user must agree to.

[0124] Finally, the server uses HTTP / HTTPS protocol to send the generated summary and checklist to the user terminal. In this transmission process, the data is usually encoded in JSON format.

[0125] Terminal side processing

[0126] The terminal receives the summary and checklist sent from the server, analyzes the received data using JavaScript, and displays it in a user-friendly format using HTML and CSS.

[0127] The device accepts the user's operation of checking each item on the checklist and pressing the "Agree" button. This operation information is then sent back to the server. This sending process uses the Fetch API to send the collected data to the server.

[0128] User operations

[0129] The user checks the summary of the terms of use displayed on the device. The summary is concise and easy to understand, allowing the user to understand the content in a short amount of time. The user then checks each item on the checklist and checks the necessary items. After checking all the items, the user presses the Agree button, which records their agreement to the terms of use.

[0130] Specific examples

[0131] Server-side processing example

[0132] The server retrieves the "Terms of Use.pdf" and converts it to text data using the PyPDF2 library. It then tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. Finally, it uses the BERT model to generate summaries of important sections and summarize them in plain text.

[0133] Example of terminal processing

[0134] The device receives the summary and checklist sent from the server, displays them on the screen using HTML and JavaScript, accepts the user's checkmarks on the checklist and clicks the consent button, and sends the collected response data to the server.

[0135] User operation example

[0136] The user checks the summary displayed on the device, checks the important items, and after checking all the items, presses the "Agree" button to agree to the terms and conditions.

[0137] Prompt Sentence Examples

[0138] "Write code to convert the new terms of use PDF document into text data, parse it, and generate a summary and checklist."

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

[0140] Step 1: Get the terms

[0141] The server obtains the new terms of use (e.g., "Terms of Use.pdf") from the service provider. The obtained PDF document is saved in the file system.

[0142] Input: Terms of use provided by the service provider in PDF format.

[0143] Output: PDF file saved on the server's file system.

[0144] Step 2: Convert PDF to text data

[0145] The server uses the PyPDF2 library to convert the PDF file into text data. Specifically, it uses the PdfFileReader class to extract the contents of each page into text.

[0146] Input: PDF file.

[0147] Output: The converted text data.

[0148] Step 3: Analyzing the text data

[0149] The server analyzes the text data using natural language processing (NLP) techniques. First, it uses the NLTK library to tokenize the text and split each word. Then it uses TF-IDF to extract important keywords and summarizes the main sections using the BERT model.

[0150] Input: Text data.

[0151] Output: Key keywords and a summary statement.

[0152] Step 4: Generate a summary

[0153] Based on the analysis, the server compiles a plain-language summary of the key points, which is formatted according to pre-defined guidelines and templates.

[0154] Input: Analysis results (important keywords, main sections).

[0155] Output: A plain text summary.

[0156] Step 5: Create a checklist

[0157] The server selects important points from the generated summary and creates a checklist, which includes items that the user must agree to.

[0158] Input: Abstract text.

[0159] Output: Checklist.

[0160] Step 6: Sending data

[0161] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol, with the data encoded in JSON format.

[0162] Input: Summary statement and checklist.

[0163] Output: Data sent to the user's terminal.

[0164] Step 7: Receive and display data

[0165] The terminal receives the summary and checklist sent from the server, analyzes the data, and displays it in a user-friendly format using HTML and JavaScript.

[0166] Input: The data sent by the server.

[0167] Output: On-screen summary and checklist.

[0168] Step 8: Collect user responses

[0169] The terminal accepts the user's operation of checking each item on the checklist and pressing the "Agree" button. This response information is temporarily stored in the terminal.

[0170] Input: User operation (checking and pressing the agree button).

[0171] Output: Collected response information.

[0172] Step 9: Sending the user's response

[0173] The device sends the collected user response information to the server, again using the Fetch API, with the data encoded in JSON format.

[0174] Input: Collected user response information.

[0175] Output: The data sent to the server.

[0176] Step 10: Record the user's agreement and consent

[0177] The server receives the response data sent from the terminal and records that the user has agreed to the terms and conditions, thereby managing the user's consent status.

[0178] Input: Response data sent from the terminal.

[0179] Output: User consent information recorded in a database.

[0180] (Application example 1)

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

[0182] The current way terms of use are presented is difficult for users to understand, and reading the lengthy terms is a hassle. As a result, users may miss important parts of the terms of use or fail to properly confirm their agreement. Furthermore, when the terms of use are changed, users are not notified promptly, making it difficult for them to know whether they have agreed to the latest terms. This increases the likelihood of disputes between service providers and users.

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

[0184] In this invention, the server includes means for converting the terms of use obtained from the service provider into text data, means for analyzing the converted text data and extracting important parts, means for detecting changes to the terms of use and sending a notification to the user terminal, means for selecting particularly important items from the generated summary and creating a checklist, and means for displaying the summary and checklist when the user taps the notification. This allows the important parts of the terms of use to be presented to the user in an easy-to-understand manner, enabling the user to quickly and reliably check important items.

[0185] "Service provider" refers to an institution or organization that provides a service.

[0186] "Terms of Use" refers to a document that stipulates the terms and conditions of use and restrictions of the Service.

[0187] "Means for converting to text data" refers to methods and tools for converting non-text data, such as PDFs and image files, into text format.

[0188] "Means of analyzing and extracting important parts" refers to techniques and methods for analyzing text data using natural language processing technology, etc., and selecting particularly important information from it.

[0189] "Means for generating a summary" refers to techniques or methods for generating concise sentences that are easy for users to understand based on analyzed data.

[0190] "Means for selecting particularly important items and creating a checklist" refers to techniques and methods for selecting items of high importance from the generated summary text and compiling them into a list.

[0191] "Means for transmitting to the user terminal" refers to the communication technology or method for transmitting the generated summary and checklist to the terminal used by the user.

[0192] "Means for detecting changes to the Terms of Use" refers to technologies or methods for automatically detecting changes to the Terms of Use.

[0193] "Means for sending notifications" refers to the technology or method for sending notifications to inform users of changes to the Terms of Use or important matters.

[0194] "Means for displaying the summary and checklist" refers to a technique or method for visually displaying the summary and checklist on a user terminal.

[0195] The present invention is a system that provides users with terms of use obtained from service providers in an easy-to-understand format and confirms their agreement with important items. The main components of this system are a server and a user terminal, and the roles of each are described in detail below.

[0196] Server-side processing

[0197] Obtaining the regulations and converting them into text data

[0198] The server obtains the new terms of use from the service provider. The terms of use are usually provided in PDF format, and to convert them into text data, a library such as PyPDF2 is used.

[0199] Parsing Terms

[0200] The server analyzes the text data using natural language processing (NLP) techniques to identify major sections and extract important keywords, using advanced summarization techniques such as the NLTK library, TF-IDF, and the BERT model.

[0201] Summary generation

[0202] Based on the key parts of the analysis, the server generates a summary in plain language. This summary is generated using a generative AI model (such as GPT-3 (registered trademark)) and provided in a format that is easy for users to understand.

[0203] Creating a summary checklist

[0204] Particularly important points are selected from the generated summary and a checklist is created, which contains important items that the user must agree to.

[0205] Sending data

[0206] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0207] Detect changes to terms and conditions and send notifications

[0208] The server detects changes to the terms of use and sends push notifications to user devices accordingly, allowing users to quickly access the latest terms of use.

[0209] Terminal side processing

[0210] Receiving and displaying data

[0211] The user device receives the summary and checklist sent from the server and displays them on the screen using HTML, CSS, and JavaScript.

[0212] Collecting user responses

[0213] The user terminal accepts the user's operation of checking each item on the checklist and pressing the "agree" button. Information based on this operation is sent to the server.

[0214] Sending data

[0215] The user device sends the user's response data (checklist and consent history) to the server, which records the user's consent status and helps prevent problems.

[0216] User operations

[0217] Check the terms and conditions

[0218] The user checks the summary of the terms of use displayed on the device. The summary is concise and easy to understand, allowing the user to understand the content in a short amount of time.

[0219] Check the items

[0220] The user checks each item in the checklist, which lists the most important points in the terms of use and displays them in an easy-to-understand format.

[0221] consent

[0222] The user completes the checklist, checks the necessary items, and then presses the "Agree" button. This operation records that the user has agreed to the terms and conditions.

[0223] Specific examples

[0224] For example, when a shopping site publishes new terms of use, users are notified with a prompt like this:

[0225] The new Terms of Use have been published. To review the contents, please open the "Easy Terms of Use Checker" and check the summary and checklist. You must agree to all important items.

[0226] Users can tap the notification to open the app, review the summary and checklist, and agree to the contents to prevent any problems with the service provider.

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

[0228] Step 1:

[0229] The server obtains new terms of use from the service provider. The obtained terms of use are usually in PDF format, and are converted to text data using, for example, the PyPDF2 library. The input is a PDF file, and the output is text data. Converting it to text data makes it easier to analyze later.

[0230] Step 2:

[0231] The server analyzes the converted text data using natural language processing (NLP) techniques. Specifically, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It also summarizes important sections using the BERT model. The input is text data, and the output is important keywords and summaries. This analysis effectively extracts the most important parts of the terms.

[0232] Step 3:

[0233] The server generates a summary in simple language based on the analyzed key parts. The summary is created using a generative AI model (e.g., GPT-3). The input is the analysis result, and the output is a summary that is easy for users to understand. This summary is easy for users to understand, allowing them to grasp the important content in a short amount of time.

[0234] Step 4:

[0235] The server selects particularly important items from the generated summary and creates a checklist. Pre-defined importance criteria are used to create the checklist. The input is the summary, and a checklist containing important items is generated as output. Using this checklist makes it easier for users to check particularly important items.

[0236] Step 5:

[0237] The server sends the generated summary and checklist to the user's terminal. The HTTP / HTTPS protocol is used for transmission. The input is the summary and checklist, and the output is a notification of completion of transmission. By receiving this, the user can confirm important parts of the terms and conditions.

[0238] Step 6:

[0239] The server detects changes to the terms of use and sends a notification to the user's device based on the changes. A change detection algorithm is used to detect changes. The input is the difference information between the old and new terms of use, and the output is a notification message. This notification allows the user to quickly obtain the latest terms of use information.

[0240] Step 7:

[0241] The user checks the summary of the terms of use displayed on the terminal and confirms each item on the checklist. The user checks each item on the checklist and presses the "Agree" button. This input action generates consent confirmation information as output. This consent confirmation information is sent to the server, and the user's consent status is appropriately recorded.

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

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

[0244] The present invention is a system that provides the content of terms of use in a form that is easy for the user to understand, confirms consent to important items, and further combines it with an emotion engine for recognizing the user's emotions. Specific embodiments for carrying out the present invention will be described below.

[0245] 1. Server-side processing

[0246] Obtaining the regulations and converting them into text data

[0247] The server retrieves the new terms of use from the service provider. This is usually a PDF document. The server uses a library (e.g., PyPDF2) to extract the text data from this PDF file.

[0248] Text Preprocessing

[0249] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[0250] Parsing Terms

[0251] The server analyzes the preprocessed text using natural language processing (NLP) techniques.

[0252] The server tokenizes the text and splits it into sentences and phrases.

[0253] The server uses importance evaluation techniques such as TF-IDF to extract important keywords and phrases.

[0254] The server uses the BERT model to generate summaries for each important section.

[0255] Summary generation

[0256] Based on the key parts of the analysis, the server generates a plain-language summary, which is generated according to pre-defined guidelines and templates and presented in a format that is easy for users to understand.

[0257] Creating a summary checklist

[0258] The server selects the most important points from the generated summary and creates a checklist containing important items that the user must agree to.

[0259] For example, generate an item in the form "■ You must be 18 years of age or older to use this service."

[0260] Sending data

[0261] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0262] 2. Terminal processing

[0263] Receiving and displaying data

[0264] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[0265] Emotion recognition with emotion engine

[0266] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time to understand how the user is reacting to the information displayed.

[0267] Collecting user responses

[0268] The device accepts the user's operation of checking each check box and pressing the "Agree" button. Depending on the user's emotional state, it is possible to further simplify the explanation or provide supplementary information.

[0269] Sending data

[0270] The device sends the user's responses (checklist status and consent information) and emotion data to the server using the HTTP / HTTPS protocol.

[0271] 3. User Operation

[0272] Check the terms and conditions

[0273] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[0274] Check the items

[0275] The user checks each item in the checklist, which lists particularly important matters in the terms of use.

[0276] consent

[0277] The user completes the checklist and checks the necessary items. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[0278] Specific examples

[0279] Server-side processing example

[0280] The server retrieves "Service A Terms of Use.pdf" and converts it into text data using the PyPDF2 library. Next, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It then uses the BERT model to generate a summary of the important sections and summarize them in plain text. It selects important points and creates a checklist. Finally, it sends the summary and checklist to the user's device.

[0281] Example of terminal processing

[0282] The device receives the summary and checklist sent from the server and displays them on the screen. It uses an emotion engine to analyze the user's facial expressions and voice and provides feedback according to the user's emotional state. When the user checks the checkboxes and presses the consent button, the collected response data and emotional data are sent to the server.

[0283] User operation example

[0284] The user checks the summary displayed on the device and ticks the important points. After checking all the check items, taking into consideration the feedback analyzed by the emotion engine, the user presses the "Agree" button. This indicates consent to the terms and conditions, and this consent is recorded.

[0285] The processing flow will be explained below.

[0286] Server Processing

[0287] Step 1: Obtaining the terms and converting them to text data

[0288] The server retrieves the new terms of use from the service provider. This is usually a PDF document. The server uses a library (e.g., PyPDF2) to extract the text data from this PDF file.

[0289] Step 2: Preprocessing the text

[0290] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[0291] Step 3: Parsing the Terms

[0292] The server analyzes the preprocessed text using natural language processing (NLP) techniques. Specifically, it performs the following operations:

[0293] The server tokenizes the text and splits it into sentences and phrases.

[0294] The server uses importance evaluation techniques such as TF-IDF to extract important keywords and phrases.

[0295] The server uses the BERT model to generate summaries for each important section.

[0296] Step 4: Generate a summary

[0297] The server generates a summary in plain language based on the key parts of the analysis, using pre-defined templates and guidelines to avoid technical jargon and difficult expressions and make the summary easy for users to understand.

[0298] Step 5: Create a summary checklist

[0299] The server selects particularly important points from the generated summary and creates a checklist. The checklist contains important items that the user must agree to. For example, it generates items in a specific format such as "■ You must be 18 years of age or older to use this service."

[0300] Step 6: Send the data

[0301] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0302] Terminal handling

[0303] Step 1: Receiving and displaying data

[0304] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[0305] Step 2: Emotion recognition by the emotion engine

[0306] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time to understand how the user is reacting to the information displayed.

[0307] Step 3: Provide feedback

[0308] The device provides appropriate feedback to the user based on the analysis results obtained from the emotion engine. If the user's level of understanding is low, the device may display a more concise explanation or provide additional information.

[0309] Step 4: Collect user responses

[0310] The terminal accepts the user's operation to check each check item, and after the user has confirmed all items, accepts the user's press of the consent button.

[0311] Step 5: Send the data

[0312] The device sends the user's responses (checklist status and consent information) and emotion data to the server using the HTTP / HTTPS protocol.

[0313] User operations

[0314] Step 1: Review the terms and conditions

[0315] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[0316] Step 2: Check the items

[0317] The user checks each item on the checklist, which lists the most important points in the terms of use.

[0318] Step 3: Accept

[0319] The user checks the checklist and checks each item. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[0320] Example 2

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

[0322] In today's world, with many services being provided online, terms of use are important, legally binding documents. However, these documents are often lengthy and full of technical terms, which creates a problem: many users agree to the terms without fully understanding them. It is also difficult to verify whether users actually agree to the terms. Furthermore, understanding the emotional state of users when they agree is crucial, but current systems are unable to address this issue.

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

[0324] In this invention, the server includes: means for converting terms of use obtained from a service provider into text data; means for normalizing unnecessary spaces, line breaks, and special characters from the converted text data; means for analyzing the converted and normalized text data and extracting important parts; means for generating a summary of the extracted important parts in plain language; means for selecting particularly important matters from the generated summary and creating a checklist; means for transmitting the generated summary and checklist to a user terminal; and means including an emotion engine for analyzing the user's emotional state. This allows the user to easily understand the contents of the terms of use and reliably obtain consent to important matters. Furthermore, analyzing the user's emotional state enables further feedback and adaptive responses.

[0325] "Service Provider" refers to a legal entity or individual that provides a particular service to a User.

[0326] "Terms of Use" refers to a document that describes the terms and rules of use for the services provided by a service provider.

[0327] "Means for converting to text data" refers to technology or methods for converting document formats such as PDF into text format.

[0328] "Normalization" refers to the process of systematically organizing and removing unnecessary spaces, line breaks, and special characters to maintain data consistency.

[0329] "Analysis" refers to the process of analyzing text data using natural language processing and other techniques to extract meaning and important information.

[0330] "Tokenization" refers to the process of breaking text into smaller units such as words, sentences, or phrases.

[0331] "Important parts" refers to sections or keywords in the Terms of Use that are deemed to be particularly important to users.

[0332] A "summary" is a short document that extracts important information from the original text and summarizes it in simple language.

[0333] A "checklist" is a document that lists important items and things that need to be checked.

[0334] "User terminal" refers to a device such as a smartphone, tablet, or PC that a user uses to access the service.

[0335] An "emotion engine" is a technology that analyzes a user's facial expressions and voice, and refers to a system for estimating the user's emotional state.

[0336] This invention is a system that provides users with terms of use in an easy-to-understand format, confirms their agreement to important items, and combines an emotion engine to recognize the user's emotions. This system operates in cooperation with the server, terminal, and user elements.

[0337] Server-side processing

[0338] The server first obtains the new terms of use from the service provider. This is usually a PDF document. The server uses software to convert the document to text data, such as the PyPDF2 library. The server uses this library to extract the text data from the PDF file.

[0339] The extracted text data is difficult to analyze as is, so unnecessary spaces, line breaks, and special characters are normalized. This is done using regular expression processing, etc. The server then analyzes the normalized text data using natural language processing (NLP) techniques. For example, this analysis involves tokenizing the text using the NLTK library and extracting important keywords using TF-IDF techniques.

[0340] The server then uses a generative AI model, such as the BERT model, to generate a summary of each important section. This summary is then written in plain language, making it easy for users to understand. The server then selects the most important points from the summary and creates a checklist, which includes key items that users should agree to.

[0341] Finally, the server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0342] Terminal side processing

[0343] The device receives the summary and checklist sent from the server and displays them in a format that is easy for the user to understand. This display uses HTML, CSS, and JavaScript. In addition, the device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time. This emotion engine is used to understand how the user is reacting to the displayed information, and uses OpenCV or TENSORFLOW (registered trademark), for example.

[0344] The device also accepts the user's operation of checking checklist items and pressing the "Agree" button. Depending on the user's emotional state, the device can further simplify the explanation or provide additional supplementary information. The device then transmits the collected response data and emotional data to the server.

[0345] User operations

[0346] The user checks the summary of the terms of use displayed on the device. The summary is written in simple language so that the content can be understood in a short time. Next, the user checks each item on the checklist and checks the necessary items. After checking all the items, the user presses the "Agree" button to agree to the terms of use. This records the user's agreement.

[0347] Specific examples

[0348] The server retrieves "Service A Terms of Use.pdf" and converts it into text data using the PyPDF2 library. Next, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It then uses the BERT model to generate a summary of the important sections and summarize them in plain text. It selects important points and creates a checklist. Finally, it sends the summary and checklist to the user's device.

[0349] The device receives the summary and checklist sent from the server and displays them on the screen. It uses an emotion engine (e.g., OpenCV or TensorFlow) to analyze the user's facial expressions and voice and provide feedback according to the user's emotional state. When the user checks the checkboxes and presses the consent button, the collected response data and emotional data are sent to the server.

[0350] The user checks the summary displayed on the device and ticks the important points. After checking all the check items, taking into consideration the feedback analyzed by the emotion engine, the user presses the "Agree" button. This indicates consent to the terms and conditions, and this consent is recorded.

[0351] Prompt Sentence Examples

[0352] "What library will the server use to extract text data from PDF files? And what technique will it use to extract important keywords?"

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

[0354] Step 1:

[0355] The server obtains a PDF file of the terms of use (e.g., "ServiceATermsOfUse.pdf") from the service provider. The obtained PDF file is saved in a specific directory on the server. The input for this step is "ServiceATermsOfUse.pdf", and the output is the PDF file saved in the specified directory on the server.

[0356] Step 2:

[0357] The server uses the PyPDF2 library to extract text data from PDF files. It receives a PDF file as input and obtains text data as output. Specifically, it opens the PDF file and extracts text from each page sequentially. This process converts the contents of "Service A Terms of Use.pdf" into pure text data.

[0358] Step 3:

[0359] The server normalizes the extracted text data to remove unnecessary whitespace, line breaks, and special characters. The input is the extracted raw text data, and the output is the normalized, clean text data. Specifically, it uses regular expressions to remove unnecessary whitespace and line breaks and format the text into a consistent format.

[0360] Step 4:

[0361] The server analyzes the normalized text data using natural language processing (NLP) techniques. First, it tokenizes the text using the NLTK library. The input is normalized text data, and the output is tokenized text. Specifically, it splits the text into words, sentences, and phrases.

[0362] Step 5:

[0363] The server extracts important keywords and phrases using TF-IDF technology. The input is tokenized text data, and the output is a list of important keywords and phrases. Specifically, it calculates the frequency of occurrence of each word or phrase and evaluates its importance.

[0364] Step 6:

[0365] The server uses a generative AI model, such as the BERT model, to generate summaries for each key section. The input is text data containing important keywords and phrases, and the output is a summary. Specifically, the server analyzes the text using a pre-trained BERT model and generates a summary.

[0366] Step 7:

[0367] The server selects particularly important items from the generated summary and creates a checklist. The input is the summary, and the output is the checklist. Specifically, the server evaluates the summary and extracts important items that the user should check.

[0368] Step 8:

[0369] The server sends the generated summary and checklist to the user terminal. The input is the summary and checklist, and the output is transmission to the user terminal. Specifically, the data is sent using the HTTP / HTTPS protocol.

[0370] Step 9:

[0371] The terminal receives the summary and checklist sent from the server. The input is the data sent from the server, and the output is the display of the received summary and checklist. Specific operations use HTML, CSS, and JavaScript to display the received data on the screen.

[0372] Step 10:

[0373] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time. The input is the user's facial expressions and voice, and the output is emotional data as the analysis result. Specifically, it collects user data via a camera and microphone and uses analysis software to estimate the user's emotional state.

[0374] Step 11:

[0375] The terminal accepts the user's operation of checking each item on the checklist and pressing the consent button. The input is the user's operation, and the output is the checklist status and consent information. Specifically, the terminal accepts user input through a user interface.

[0376] Step 12:

[0377] The terminal sends the collected response data and emotion data to the server. The input is the user's response data and emotion data, and the output is transmission to the server. Specifically, the data is sent using the HTTP / HTTPS protocol.

[0378] Step 13:

[0379] The user checks the summary displayed on the terminal and checks the important items. The input is the summary and the checklist, and the output is the checked checklist. Specifically, the user reads each item and checks the necessary items.

[0380] Step 14:

[0381] After the user has checked all the check items, they press the Agree button. The input is the checked checklist, and the output is an expression of consent. Specifically, the user indicates consent by pressing the Agree button based on the items they have checked.

[0382] (Application example 2)

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

[0384] Conventional terms of service confirmation systems present users with lengthy, difficult-to-understand terms and conditions, making it difficult for them to efficiently review important parts and resulting in a poor user experience. Furthermore, in autonomous vehicles, if consent to the terms and conditions is not obtained quickly and reliably, it could affect safety and service quality. Furthermore, providing information uniformly without considering the user's emotional state can also cause problems, with some users being unable to accurately understand the content.

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

[0386] In this invention, the server includes means for converting the terms of use acquired from the service provider into text data, means for analyzing the converted text data and extracting important parts, means for generating a summary of the extracted important parts in plain language, means for selecting particularly important matters from the generated summary and creating a checklist, means for transmitting the generated summary and checklist to a user terminal, emotion recognition means for analyzing the user's emotions in real time in the user terminal to obtain user consent for the autonomously driving vehicle, and means for providing additional explanations according to the user's emotional state. This enables the user to confirm important matters of the terms of use in an easy-to-understand format, obtain consent quickly and reliably, and further enables flexible provision of information according to the user's emotional state.

[0387] "Service Provider" refers to a company or organization that offers a particular service or product.

[0388] "Terms of Use" refers to a document that lists the rules and conditions that users must follow when using a service.

[0389] "Text data" refers to information stored as character string data.

[0390] "Means for converting" refers to a method or device for converting data of one format into another format.

[0391] "Means for analysis" refers to methods and devices for analyzing data and understanding its contents.

[0392] "Important parts" refers to information or content that is particularly important within the whole.

[0393] "Plain writing" refers to writing that is easy to understand and simply written.

[0394] A "summary" is a sentence that summarizes a longer piece of text in a short form.

[0395] A "checklist" is a list of items to be checked.

[0396] "User terminal" refers to a device used by a user, including a personal computer or smartphone.

[0397] "Emotion recognition means" refers to a method or device for analyzing and understanding a user's emotions.

[0398] "Additional explanation" refers to an explanation added to supplement the original explanation.

[0399] "Agreement button" refers to a button that allows a user to indicate their consent to certain matters.

[0400] "Natural language processing technology" refers to the technology that uses computers to process and understand human language.

[0401] This invention is a system that optimizes the process for users of autonomous vehicles to confirm terms of use in an easy-to-understand manner and agree to important matters. This system consists of a server side and a terminal side, and the functions and processing methods of each are explained below.

[0402] Server-side processing

[0403] Obtaining rules and converting them to text data

[0404] The server retrieves the new terms of service from the service provider, usually as a PDF document, and uses the PyPDF2 library to extract the text data from the PDF file.

[0405] Text Preprocessing

[0406] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[0407] Parsing Terms

[0408] The server analyzes the preprocessed text using natural language processing (NLP) techniques, tokenizing the text and extracting important keywords and phrases using importance evaluation techniques such as TF-IDF, and then generates summaries for each important section using the BERT model.

[0409] Summary and checklist generation

[0410] Based on the analyzed important parts, the server generates a summary in plain language. This summary is generated according to pre-defined guidelines and templates and is provided in a format that is easy for users to understand. Particularly important points are selected from the generated summary to create a checklist.

[0411] Sending data

[0412] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0413] Terminal side processing

[0414] Receiving and displaying data

[0415] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[0416] Emotion recognition with emotion engine

[0417] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time to understand how the user is reacting to the information displayed.

[0418] Collecting user responses

[0419] The device accepts the user's operation of checking each check box and pressing the "Agree" button. It is also possible to further simplify the explanation or provide supplementary information depending on the user's emotional state.

[0420] Sending data

[0421] The device sends the user's responses (checklist status and consent information) and emotion data to the server using the HTTP / HTTPS protocol.

[0422] User operations

[0423] Check the terms and conditions

[0424] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[0425] Check the items

[0426] The user checks each item in the checklist, which lists particularly important matters in the terms of use.

[0427] consent

[0428] The user completes the checklist and checks the necessary items. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[0429] Specific examples and prompts for the generative AI model

[0430] As a concrete example, consider the procedure for getting into a self-driving car. Since many users find it tedious to read the service's terms of use all at once, the system presents important information succinctly and analyzes the user's emotional state to provide feedback, facilitating the consent process.

[0431] Example prompt sentence:

[0432] Your goal is to create a Python program that converts PDF-formatted terms of use into an easy-to-understand summary for users, and then obtains their consent to key terms. On the server side, you will use the PyPDF2 library to extract text and create a summary using the BERT model. On the device side, you will analyze user sentiment and manage the consent process.

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

[0434] Step 1:

[0435] The server receives the new terms of use in PDF format from the service provider. The input is a PDF document, which is saved on the server. The output is the PDF file itself.

[0436] Step 2:

[0437] The server extracts text data from a PDF file using the PyPDF2 library by opening the PDF file and getting the text from each page sequentially. The input is the PDF file, and the output is the extracted text data.

[0438] Step 3:

[0439] The server preprocesses the extracted text data. In this process, unnecessary line breaks, spaces, and special characters are removed from the text. The input is the extracted text data, and the output is the preprocessed, clean text data.

[0440] Step 4:

[0441] The server analyzes the preprocessed text data using natural language processing (NLP) techniques. This involves tokenizing the text and extracting important keywords and phrases using TF-IDF. It then generates summaries for each important section using the BERT model. The input is the preprocessed text data, and the output is important keywords and summary sentences.

[0442] Step 5:

[0443] The server generates a plain-language summary based on the key parts of the analysis. The summary is created according to pre-defined guidelines and templates. The input is key keywords and a draft summary, and the output is the final summary in a format that is easy for the user to understand.

[0444] Step 6:

[0445] The server selects particularly important items from the generated summary and creates a checklist. The input is the summary, and the output is a checklist that lists the particularly important items.

[0446] Step 7:

[0447] The server sends the generated summary and checklist to the user terminal via HTTP / HTTPS protocol. The input is the summary and checklist, and the output is the data sent to the user terminal.

[0448] Step 8:

[0449] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format. HTML, CSS, and JavaScript are used for display. The input is the summary and checklist sent from the server, and the output is the content displayed on the user's screen.

[0450] Step 9:

[0451] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time. The emotion engine analyzes how the user reacts to displayed information and grasps their emotional state. The input is the user's facial expressions and voice, and the output is analyzed emotional state data.

[0452] Step 10:

[0453] The device further simplifies the explanation or provides supplementary information according to the user's emotional state. The input is emotional state data, and the output is an explanation optimized according to the user's level of understanding and emotions.

[0454] Step 11:

[0455] The terminal accepts the user's operation of checking each check item and pressing the consent button. Based on the user's operation, the terminal collects the checklist status and consent information. The input is the user's operation, and the output is the collected user response data.

[0456] Step 12:

[0457] The terminal sends the collected response data and emotion data to the server using the HTTP / HTTPS protocol. The input is the user's response data and emotion data, and the output is the data sent to the server.

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

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

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

[0461] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0474] The present invention provides a system for providing the content of terms of use in a form that is easy for the user to understand and for confirming consent to important items. Specific embodiments for carrying out the present invention will be described below.

[0475] 1. Server-side processing

[0476] Obtaining the regulations and converting them into text data

[0477] The server obtains new terms of service from the service provider (e.g., "Service A Terms of Service.pdf"). These terms are usually in PDF format, and a library (e.g., PyPDF2) is used to convert them into text data.

[0478] Parsing Terms

[0479] The server analyzes the text data using natural language processing (NLP) techniques to identify key sections (e.g., terms of use, privacy, liability, etc.) and extract important keywords using tokenization, importance assessment (e.g., TF-IDF), and summarization techniques (e.g., the BERT model).

[0480] Summary generation

[0481] Based on the key parts of the analysis, the server generates a plain-language summary, which is generated according to pre-defined guidelines and templates and presented in a format that is easy for users to understand.

[0482] Creating a summary checklist

[0483] From the generated summary, particularly important points are selected and a checklist is created. The checklist includes important items that users must agree to (e.g., "You must be 18 years of age or older to use this service").

[0484] Sending data

[0485] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0486] 2. Terminal processing

[0487] Receiving and displaying data

[0488] The terminal receives the summary and checklist sent from the server, analyzes this data, and displays it in a user-friendly format using HTML, CSS, and JavaScript.

[0489] Collecting user responses

[0490] The terminal accepts the user's operation of checking each item on the checklist and pressing the "Agree" button. Information based on this operation is sent to the server.

[0491] Sending data

[0492] The device sends the user's response (checklist and consent history) to the server, which records the user's consent status and helps prevent problems.

[0493] 3. User Operation

[0494] Check the terms and conditions

[0495] The user checks the summary of the terms of use displayed on the device. The summary is concise and easy to understand, allowing the user to understand the content in a short amount of time.

[0496] Check the items

[0497] The user checks each item in the checklist, which lists the most important points in the terms of use and displays them in an easy-to-understand format.

[0498] consent

[0499] The user completes the checklist, checks the necessary items, and then presses the "Agree" button. This operation records that the user has agreed to the terms and conditions.

[0500] Specific examples

[0501] Server-side processing example

[0502] The server retrieves "Service A Terms of Use.pdf" and converts it to text data using the PyPDF2 library. Next, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It then uses the BERT model to generate a summary of the important sections and summarize them in plain text. It then selects important points and creates a checklist. Finally, it sends the summary and checklist to the user's device.

[0503] Example of terminal processing

[0504] The terminal receives the summary and checklist sent from the server, displays them on the screen, accepts the user's checkmarks on the checklist and presses the consent button, and sends the collected response data to the server.

[0505] User operation example

[0506] The user checks the summary displayed on the device, checks the important items, and after checking all the items, presses the "Agree" button to agree to the terms and conditions.

[0507] The processing flow will be explained below.

[0508] Server Processing

[0509] Step 1: Obtaining the terms and converting them to text data

[0510] The server retrieves the new terms of use from the service provider. This is usually a PDF document. The server uses a library (e.g., PyPDF2) to extract the text data from this PDF file.

[0511] Step 2: Preprocessing the text

[0512] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[0513] Step 3: Parsing the Terms

[0514] The server analyzes the preprocessed text using natural language processing (NLP) techniques.

[0515] The server tokenizes the text and splits it into sentences and phrases.

[0516] The server uses importance evaluation techniques such as TF-IDF to extract important keywords and phrases.

[0517] The server uses the BERT model to generate summaries for each important section.

[0518] Step 4: Generate a summary

[0519] The server then converts the summary generated from the analyzed key sections into plain text using pre-defined templates and guidelines, avoiding technical jargon and complex language to make it easier for users to understand.

[0520] Step 5: Create a summary checklist

[0521] The server selects particularly important points from the generated summary and creates a checklist, which contains important items that the user must agree to.

[0522] For example, generate an item in the form "■ You must be 18 years of age or older to use this service."

[0523] Step 6: Send the data

[0524] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0525] Terminal handling

[0526] Step 1: Receiving and displaying data

[0527] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[0528] Step 2: Collect user responses

[0529] The terminal accepts the user's operation of checking each check item, and after the user has confirmed all items, accepts the user's pressing of the "Agree" button.

[0530] Step 3: Send the data

[0531] The terminal sends the user's response (checklist status and consent information) to the server using the HTTP / HTTPS protocol.

[0532] User operations

[0533] Step 1: Review the terms and conditions

[0534] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[0535] Step 2: Check the items

[0536] The user checks each item in the checklist, which lists particularly important matters in the terms of use.

[0537] Step 3: Accept

[0538] The user checks the checklist and checks each item. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[0539] Example 1

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

[0541] In today's world, many users find it difficult to understand the terms of service. Terms of service are usually lengthy and contain many technical terms and legal expressions, making it difficult for the average user to quickly and accurately grasp their content. Furthermore, there is a high risk of trouble or disputes arising due to insufficient confirmation of consent to important terms. There is a need for a system that can solve these issues and enable users to easily understand terms of service and properly consent to important terms.

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

[0543] In this invention, the server includes means for converting the terms of use obtained from the service provider into text data, means for analyzing the converted text data, identifying major sections, and extracting important keywords, means for generating a summary in plain language of the extracted important parts, means for selecting particularly important matters from the generated summary and creating a checklist, and means for transmitting the generated summary and checklist to a user terminal, thereby enabling the user to quickly understand the important contents of the terms of use and appropriately agree to particularly important items.

[0544] A "service provider" is an organization or individual that provides a service to a user.

[0545] "Terms of Use" means the document that sets out the terms, conditions and regulations for use of the Service.

[0546] "Text data" refers to data in which character information is expressed in digital form.

[0547] To "convert" means to change from one form or state to another.

[0548] "Analyzing" means breaking down data or information and clarifying its structure and meaning.

[0549] "Major sections" are parts or sections of a document that are particularly important.

[0550] "Important keywords" are words or phrases that are considered to be particularly important within a document.

[0551] "Simple writing" refers to writing written in simple, easy-to-understand language that is easy for anyone to understand.

[0552] A "summary" is a short sentence that succinctly summarizes the contents of a long document.

[0553] "To select" means to choose from among many things according to a criterion.

[0554] A "checklist" is a list of items to be checked or evaluated.

[0555] A "user terminal" refers to an electronic device such as a computer or smartphone used by a user.

[0556] "Natural language processing technology" refers to technology for processing human language using a computer.

[0557] The "BERT model" refers to a deep learning model transformed from a bidirectional encoder representation.

[0558] The present invention provides a system for providing the content of terms of use in a form that is easy for the user to understand and for confirming consent to important items. Specific embodiments for carrying out the present invention will be described below.

[0559] Server-side processing

[0560] The server first obtains the new terms of use (e.g., "Terms of Use.pdf") from the service provider. These terms are usually in PDF format, and a library (e.g., PyPDF2) is used to convert them into text data. The PyPDF2 library is used to convert the PDF document into text data.

[0561] The server then uses natural language processing (NLP) techniques to analyze the text data. This analysis process identifies major sections (e.g., terms of use, privacy, liability, etc.) and extracts important keywords. Analysis includes tokenization using the NLTK library, importance assessment using TF-IDF, and summarization using the BERT model.

[0562] Based on the analyzed important parts, the server generates a summary in plain language. This summary is generated according to pre-defined guidelines and templates and is provided in a format that is easy for the user to understand. Furthermore, it selects particularly important points from the generated summary and creates a checklist. The checklist contains important items that the user must agree to.

[0563] Finally, the server uses HTTP / HTTPS protocol to send the generated summary and checklist to the user terminal. In this transmission process, the data is usually encoded in JSON format.

[0564] Terminal side processing

[0565] The terminal receives the summary and checklist sent from the server, analyzes the received data using JavaScript, and displays it in a user-friendly format using HTML and CSS.

[0566] The device accepts the user's operation of checking each item on the checklist and pressing the "Agree" button. This operation information is then sent back to the server. This sending process uses the Fetch API to send the collected data to the server.

[0567] User operations

[0568] The user checks the summary of the terms of use displayed on the device. The summary is concise and easy to understand, allowing the user to understand the content in a short amount of time. The user then checks each item on the checklist and checks the necessary items. After checking all the items, the user presses the Agree button, which records their agreement to the terms of use.

[0569] Specific examples

[0570] Server-side processing example

[0571] The server retrieves the "Terms of Use.pdf" and converts it to text data using the PyPDF2 library. It then tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. Finally, it uses the BERT model to generate summaries of important sections and summarize them in plain text.

[0572] Example of terminal processing

[0573] The device receives the summary and checklist sent from the server, displays them on the screen using HTML and JavaScript, accepts the user's checkmarks on the checklist and clicks the consent button, and sends the collected response data to the server.

[0574] User operation example

[0575] The user checks the summary displayed on the device, checks the important items, and after checking all the items, presses the "Agree" button to agree to the terms and conditions.

[0576] Prompt Sentence Examples

[0577] "Write code to convert the new terms of use PDF document into text data, parse it, and generate a summary and checklist."

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

[0579] Step 1: Get the terms

[0580] The server obtains the new terms of use (e.g., "Terms of Use.pdf") from the service provider. The obtained PDF document is saved in the file system.

[0581] Input: Terms of use provided by the service provider in PDF format.

[0582] Output: PDF file saved on the server's file system.

[0583] Step 2: Convert PDF to text data

[0584] The server uses the PyPDF2 library to convert the PDF file into text data. Specifically, it uses the PdfFileReader class to extract the contents of each page into text.

[0585] Input: PDF file.

[0586] Output: The converted text data.

[0587] Step 3: Analyzing the text data

[0588] The server analyzes the text data using natural language processing (NLP) techniques. First, it uses the NLTK library to tokenize the text and split each word. Then it uses TF-IDF to extract important keywords and summarizes the main sections using the BERT model.

[0589] Input: Text data.

[0590] Output: Key keywords and a summary statement.

[0591] Step 4: Generate a summary

[0592] Based on the analysis, the server compiles a plain-language summary of the key points, which is formatted according to pre-defined guidelines and templates.

[0593] Input: Analysis results (important keywords, main sections).

[0594] Output: A plain text summary.

[0595] Step 5: Create a checklist

[0596] The server selects important points from the generated summary and creates a checklist, which includes items that the user must agree to.

[0597] Input: Abstract text.

[0598] Output: Checklist.

[0599] Step 6: Sending data

[0600] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol, with the data encoded in JSON format.

[0601] Input: Summary statement and checklist.

[0602] Output: Data sent to the user's terminal.

[0603] Step 7: Receive and display data

[0604] The terminal receives the summary and checklist sent from the server, analyzes the data, and displays it in a user-friendly format using HTML and JavaScript.

[0605] Input: The data sent by the server.

[0606] Output: On-screen summary and checklist.

[0607] Step 8: Collect user responses

[0608] The terminal accepts the user's operation of checking each item on the checklist and pressing the "Agree" button. This response information is temporarily stored in the terminal.

[0609] Input: User operation (checking and pressing the agree button).

[0610] Output: Collected response information.

[0611] Step 9: Sending the user's response

[0612] The device sends the collected user response information to the server, again using the Fetch API, with the data encoded in JSON format.

[0613] Input: Collected user response information.

[0614] Output: The data sent to the server.

[0615] Step 10: Record the user's agreement and consent

[0616] The server receives the response data sent from the terminal and records that the user has agreed to the terms and conditions, thereby managing the user's consent status.

[0617] Input: Response data sent from the terminal.

[0618] Output: User consent information recorded in a database.

[0619] (Application example 1)

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

[0621] The current way terms of use are presented is difficult for users to understand, and reading the lengthy terms is a hassle. As a result, users may miss important parts of the terms of use or fail to properly confirm their agreement. Furthermore, when the terms of use are changed, users are not notified promptly, making it difficult for them to know whether they have agreed to the latest terms. This increases the likelihood of disputes between service providers and users.

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

[0623] In this invention, the server includes means for converting the terms of use obtained from the service provider into text data, means for analyzing the converted text data and extracting important parts, means for detecting changes to the terms of use and sending a notification to the user terminal, means for selecting particularly important items from the generated summary and creating a checklist, and means for displaying the summary and checklist when the user taps the notification. This allows the important parts of the terms of use to be presented to the user in an easy-to-understand manner, enabling the user to quickly and reliably check important items.

[0624] "Service provider" refers to an institution or organization that provides a service.

[0625] "Terms of Use" refers to a document that stipulates the terms and conditions of use and restrictions of the Service.

[0626] "Means for converting to text data" refers to methods and tools for converting non-text data, such as PDFs and image files, into text format.

[0627] "Means of analyzing and extracting important parts" refers to techniques and methods for analyzing text data using natural language processing technology, etc., and selecting particularly important information from it.

[0628] "Means for generating a summary" refers to techniques or methods for generating concise sentences that are easy for users to understand based on analyzed data.

[0629] "Means for selecting particularly important items and creating a checklist" refers to techniques and methods for selecting items of high importance from the generated summary text and compiling them into a list.

[0630] "Means for transmitting to the user terminal" refers to the communication technology or method for transmitting the generated summary and checklist to the terminal used by the user.

[0631] "Means for detecting changes to the Terms of Use" refers to technologies or methods for automatically detecting changes to the Terms of Use.

[0632] "Means for sending notifications" refers to the technology or method for sending notifications to inform users of changes to the Terms of Use or important matters.

[0633] "Means for displaying the summary and checklist" refers to a technique or method for visually displaying the summary and checklist on a user terminal.

[0634] The present invention is a system that provides users with terms of use obtained from service providers in an easy-to-understand format and confirms their agreement with important items. The main components of this system are a server and a user terminal, and the roles of each are described in detail below.

[0635] Server-side processing

[0636] Obtaining the regulations and converting them into text data

[0637] The server obtains the new terms of use from the service provider. The terms of use are usually provided in PDF format, and to convert them into text data, a library such as PyPDF2 is used.

[0638] Parsing Terms

[0639] The server analyzes the text data using natural language processing (NLP) techniques to identify major sections and extract important keywords, using advanced summarization techniques such as the NLTK library, TF-IDF, and the BERT model.

[0640] Summary generation

[0641] Based on the key parts of the analysis, the server generates a summary in plain language. This summary is generated using a generative AI model (e.g., GPT-3) and provided in a format that is easy for users to understand.

[0642] Creating a summary checklist

[0643] Particularly important points are selected from the generated summary and a checklist is created, which contains important items that the user must agree to.

[0644] Sending data

[0645] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0646] Detect changes to terms and conditions and send notifications

[0647] The server detects changes to the terms of use and sends push notifications to user devices accordingly, allowing users to quickly access the latest terms of use.

[0648] Terminal side processing

[0649] Receiving and displaying data

[0650] The user device receives the summary and checklist sent from the server and displays them on the screen using HTML, CSS, and JavaScript.

[0651] Collecting user responses

[0652] The user terminal accepts the user's operation of checking each item on the checklist and pressing the "agree" button. Information based on this operation is sent to the server.

[0653] Sending data

[0654] The user device sends the user's response data (checklist and consent history) to the server, which records the user's consent status and helps prevent problems.

[0655] User operations

[0656] Check the terms and conditions

[0657] The user checks the summary of the terms of use displayed on the device. The summary is concise and easy to understand, allowing the user to understand the content in a short amount of time.

[0658] Check the items

[0659] The user checks each item in the checklist, which lists the most important points in the terms of use and displays them in an easy-to-understand format.

[0660] consent

[0661] The user completes the checklist, checks the necessary items, and then presses the "Agree" button. This operation records that the user has agreed to the terms and conditions.

[0662] Specific examples

[0663] For example, when a shopping site publishes new terms of use, users are notified with a prompt like this:

[0664] The new Terms of Use have been published. To review the contents, please open the "Easy Terms of Use Checker" and check the summary and checklist. You must agree to all important items.

[0665] Users can tap the notification to open the app, review the summary and checklist, and agree to the contents to prevent any problems with the service provider.

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

[0667] Step 1:

[0668] The server obtains new terms of use from the service provider. The obtained terms of use are usually in PDF format, and are converted to text data using, for example, the PyPDF2 library. The input is a PDF file, and the output is text data. Converting it to text data makes it easier to analyze later.

[0669] Step 2:

[0670] The server analyzes the converted text data using natural language processing (NLP) techniques. Specifically, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It also summarizes important sections using the BERT model. The input is text data, and the output is important keywords and summaries. This analysis effectively extracts the most important parts of the terms.

[0671] Step 3:

[0672] The server generates a summary in simple language based on the analyzed key parts. The summary is created using a generative AI model (e.g., GPT-3). The input is the analysis result, and the output is a summary that is easy for users to understand. This summary is easy for users to understand, allowing them to grasp the important content in a short amount of time.

[0673] Step 4:

[0674] The server selects particularly important items from the generated summary and creates a checklist. Pre-defined importance criteria are used to create the checklist. The input is the summary, and a checklist containing important items is generated as output. Using this checklist makes it easier for users to check particularly important items.

[0675] Step 5:

[0676] The server sends the generated summary and checklist to the user's terminal. The HTTP / HTTPS protocol is used for transmission. The input is the summary and checklist, and the output is a notification of completion of transmission. By receiving this, the user can confirm important parts of the terms and conditions.

[0677] Step 6:

[0678] The server detects changes to the terms of use and sends a notification to the user's device based on the changes. A change detection algorithm is used to detect changes. The input is the difference information between the old and new terms of use, and the output is a notification message. This notification allows the user to quickly obtain the latest terms of use information.

[0679] Step 7:

[0680] The user checks the summary of the terms of use displayed on the terminal and confirms each item on the checklist. The user checks each item on the checklist and presses the "Agree" button. This input action generates consent confirmation information as output. This consent confirmation information is sent to the server, and the user's consent status is appropriately recorded.

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

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

[0683] The present invention is a system that provides the content of terms of use in a form that is easy for the user to understand, confirms consent to important items, and further combines it with an emotion engine for recognizing the user's emotions. Specific embodiments for carrying out the present invention will be described below.

[0684] 1. Server-side processing

[0685] Obtaining the regulations and converting them into text data

[0686] The server retrieves the new terms of use from the service provider. This is usually a PDF document. The server uses a library (e.g., PyPDF2) to extract the text data from this PDF file.

[0687] Text Preprocessing

[0688] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[0689] Parsing Terms

[0690] The server analyzes the preprocessed text using natural language processing (NLP) techniques.

[0691] The server tokenizes the text and splits it into sentences and phrases.

[0692] The server uses importance evaluation techniques such as TF-IDF to extract important keywords and phrases.

[0693] The server uses the BERT model to generate summaries for each important section.

[0694] Summary generation

[0695] Based on the key parts of the analysis, the server generates a plain-language summary, which is generated according to pre-defined guidelines and templates and presented in a format that is easy for users to understand.

[0696] Creating a summary checklist

[0697] The server selects the most important points from the generated summary and creates a checklist containing important items that the user must agree to.

[0698] For example, generate an item in the form "■ You must be 18 years of age or older to use this service."

[0699] Sending data

[0700] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0701] 2. Terminal processing

[0702] Receiving and displaying data

[0703] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[0704] Emotion recognition with emotion engine

[0705] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time to understand how the user is reacting to the information displayed.

[0706] Collecting user responses

[0707] The device accepts the user's operation of checking each check box and pressing the "Agree" button. Depending on the user's emotional state, it is possible to further simplify the explanation or provide supplementary information.

[0708] Sending data

[0709] The device sends the user's responses (checklist status and consent information) and emotion data to the server using the HTTP / HTTPS protocol.

[0710] 3. User Operation

[0711] Check the terms and conditions

[0712] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[0713] Check the items

[0714] The user checks each item in the checklist, which lists particularly important matters in the terms of use.

[0715] consent

[0716] The user completes the checklist and checks the necessary items. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[0717] Specific examples

[0718] Server-side processing example

[0719] The server retrieves "Service A Terms of Use.pdf" and converts it into text data using the PyPDF2 library. Next, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It then uses the BERT model to generate a summary of the important sections and summarize them in plain text. It selects important points and creates a checklist. Finally, it sends the summary and checklist to the user's device.

[0720] Example of terminal processing

[0721] The device receives the summary and checklist sent from the server and displays them on the screen. It uses an emotion engine to analyze the user's facial expressions and voice and provides feedback according to the user's emotional state. When the user checks the checkboxes and presses the consent button, the collected response data and emotional data are sent to the server.

[0722] User operation example

[0723] The user checks the summary displayed on the device and ticks the important points. After checking all the check items, taking into consideration the feedback analyzed by the emotion engine, the user presses the "Agree" button. This indicates consent to the terms and conditions, and this consent is recorded.

[0724] The processing flow will be explained below.

[0725] Server Processing

[0726] Step 1: Obtaining the terms and converting them to text data

[0727] The server retrieves the new terms of use from the service provider. This is usually a PDF document. The server uses a library (e.g., PyPDF2) to extract the text data from this PDF file.

[0728] Step 2: Preprocessing the text

[0729] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[0730] Step 3: Parsing the Terms

[0731] The server analyzes the preprocessed text using natural language processing (NLP) techniques. Specifically, it performs the following operations:

[0732] The server tokenizes the text and splits it into sentences and phrases.

[0733] The server uses importance evaluation techniques such as TF-IDF to extract important keywords and phrases.

[0734] The server uses the BERT model to generate summaries for each important section.

[0735] Step 4: Generate a summary

[0736] The server generates a summary in plain language based on the key parts of the analysis, using pre-defined templates and guidelines to avoid technical jargon and difficult expressions and make the summary easy for users to understand.

[0737] Step 5: Create a summary checklist

[0738] The server selects particularly important points from the generated summary and creates a checklist. The checklist contains important items that the user must agree to. For example, it generates items in a specific format such as "■ You must be 18 years of age or older to use this service."

[0739] Step 6: Send the data

[0740] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0741] Terminal handling

[0742] Step 1: Receiving and displaying data

[0743] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[0744] Step 2: Emotion recognition by the emotion engine

[0745] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time to understand how the user is reacting to the information displayed.

[0746] Step 3: Provide feedback

[0747] The device provides appropriate feedback to the user based on the analysis results obtained from the emotion engine. If the user's level of understanding is low, the device may display a more concise explanation or provide additional information.

[0748] Step 4: Collect user responses

[0749] The terminal accepts the user's operation to check each check item, and after the user has confirmed all items, accepts the user's press of the consent button.

[0750] Step 5: Send the data

[0751] The device sends the user's responses (checklist status and consent information) and emotion data to the server using the HTTP / HTTPS protocol.

[0752] User operations

[0753] Step 1: Review the terms and conditions

[0754] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[0755] Step 2: Check the items

[0756] The user checks each item on the checklist, which lists the most important points in the terms of use.

[0757] Step 3: Accept

[0758] The user checks the checklist and checks each item. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[0759] Example 2

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

[0761] In today's world, with many services being provided online, terms of use are important, legally binding documents. However, these documents are often lengthy and full of technical terms, which creates a problem: many users agree to the terms without fully understanding them. It is also difficult to verify whether users actually agree to the terms. Furthermore, understanding the emotional state of users when they agree is crucial, but current systems are unable to address this issue.

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

[0763] In this invention, the server includes: means for converting terms of use obtained from a service provider into text data; means for normalizing unnecessary spaces, line breaks, and special characters from the converted text data; means for analyzing the converted and normalized text data and extracting important parts; means for generating a summary of the extracted important parts in plain language; means for selecting particularly important matters from the generated summary and creating a checklist; means for transmitting the generated summary and checklist to a user terminal; and means including an emotion engine for analyzing the user's emotional state. This allows the user to easily understand the contents of the terms of use and reliably obtain consent to important matters. Furthermore, analyzing the user's emotional state enables further feedback and adaptive responses.

[0764] "Service Provider" refers to a legal entity or individual that provides a particular service to a User.

[0765] "Terms of Use" refers to a document that describes the terms and rules of use for the services provided by a service provider.

[0766] "Means for converting to text data" refers to technology or methods for converting document formats such as PDF into text format.

[0767] "Normalization" refers to the process of systematically organizing and removing unnecessary spaces, line breaks, and special characters to maintain data consistency.

[0768] "Analysis" refers to the process of analyzing text data using natural language processing and other techniques to extract meaning and important information.

[0769] "Tokenization" refers to the process of breaking text into smaller units such as words, sentences, or phrases.

[0770] "Important parts" refers to sections or keywords in the Terms of Use that are deemed to be particularly important to users.

[0771] A "summary" is a short document that extracts important information from the original text and summarizes it in simple language.

[0772] A "checklist" is a document that lists important items and things that need to be checked.

[0773] "User terminal" refers to a device such as a smartphone, tablet, or PC that a user uses to access the service.

[0774] An "emotion engine" is a technology that analyzes a user's facial expressions and voice, and refers to a system for estimating the user's emotional state.

[0775] This invention is a system that provides users with terms of use in an easy-to-understand format, confirms their agreement to important items, and combines an emotion engine to recognize the user's emotions. This system operates in cooperation with the server, terminal, and user elements.

[0776] Server-side processing

[0777] The server first obtains the new terms of use from the service provider. This is usually a PDF document. The server uses software to convert the document to text data, such as the PyPDF2 library. The server uses this library to extract the text data from the PDF file.

[0778] The extracted text data is difficult to analyze as is, so unnecessary spaces, line breaks, and special characters are normalized. This is done using regular expression processing, etc. The server then analyzes the normalized text data using natural language processing (NLP) techniques. For example, this analysis involves tokenizing the text using the NLTK library and extracting important keywords using TF-IDF techniques.

[0779] The server then uses a generative AI model, such as the BERT model, to generate a summary of each important section. This summary is then written in plain language, making it easy for users to understand. The server then selects the most important points from the summary and creates a checklist, which includes key items that users should agree to.

[0780] Finally, the server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0781] Terminal side processing

[0782] The device receives the summary and checklist sent from the server and displays them in a user-friendly format. This display uses HTML, CSS, and JavaScript. Furthermore, the device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time. This emotion engine, which uses OpenCV and TensorFlow, for example, to understand how the user is reacting to the displayed information.

[0783] The device also accepts the user's operation of checking checklist items and pressing the "Agree" button. Depending on the user's emotional state, the device can further simplify the explanation or provide additional supplementary information. The device then transmits the collected response data and emotional data to the server.

[0784] User operations

[0785] The user checks the summary of the terms of use displayed on the device. The summary is written in simple language so that the content can be understood in a short time. Next, the user checks each item on the checklist and checks the necessary items. After checking all the items, the user presses the "Agree" button to agree to the terms of use. This records the user's agreement.

[0786] Specific examples

[0787] The server retrieves "Service A Terms of Use.pdf" and converts it into text data using the PyPDF2 library. Next, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It then uses the BERT model to generate a summary of the important sections and summarize them in plain text. It selects important points and creates a checklist. Finally, it sends the summary and checklist to the user's device.

[0788] The device receives the summary and checklist sent from the server and displays them on the screen. It uses an emotion engine (e.g., OpenCV or TensorFlow) to analyze the user's facial expressions and voice and provide feedback according to the user's emotional state. When the user checks the checkboxes and presses the consent button, the collected response data and emotional data are sent to the server.

[0789] The user checks the summary displayed on the device and ticks the important points. After checking all the check items, taking into consideration the feedback analyzed by the emotion engine, the user presses the "Agree" button. This indicates consent to the terms and conditions, and this consent is recorded.

[0790] Prompt Sentence Examples

[0791] "What library will the server use to extract text data from PDF files? And what technique will it use to extract important keywords?"

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

[0793] Step 1:

[0794] The server obtains a PDF file of the terms of use (e.g., "ServiceATermsOfUse.pdf") from the service provider. The obtained PDF file is saved in a specific directory on the server. The input for this step is "ServiceATermsOfUse.pdf", and the output is the PDF file saved in the specified directory on the server.

[0795] Step 2:

[0796] The server uses the PyPDF2 library to extract text data from PDF files. It receives a PDF file as input and obtains text data as output. Specifically, it opens the PDF file and extracts text from each page sequentially. This process converts the contents of "Service A Terms of Use.pdf" into pure text data.

[0797] Step 3:

[0798] The server normalizes the extracted text data to remove unnecessary whitespace, line breaks, and special characters. The input is the extracted raw text data, and the output is the normalized, clean text data. Specifically, it uses regular expressions to remove unnecessary whitespace and line breaks and format the text into a consistent format.

[0799] Step 4:

[0800] The server analyzes the normalized text data using natural language processing (NLP) techniques. First, it tokenizes the text using the NLTK library. The input is normalized text data, and the output is tokenized text. Specifically, it splits the text into words, sentences, and phrases.

[0801] Step 5:

[0802] The server extracts important keywords and phrases using TF-IDF technology. The input is tokenized text data, and the output is a list of important keywords and phrases. Specifically, it calculates the frequency of occurrence of each word or phrase and evaluates its importance.

[0803] Step 6:

[0804] The server uses a generative AI model, such as the BERT model, to generate summaries for each key section. The input is text data containing important keywords and phrases, and the output is a summary. Specifically, the server analyzes the text using a pre-trained BERT model and generates a summary.

[0805] Step 7:

[0806] The server selects particularly important items from the generated summary and creates a checklist. The input is the summary, and the output is the checklist. Specifically, the server evaluates the summary and extracts important items that the user should check.

[0807] Step 8:

[0808] The server sends the generated summary and checklist to the user terminal. The input is the summary and checklist, and the output is transmission to the user terminal. Specifically, the data is sent using the HTTP / HTTPS protocol.

[0809] Step 9:

[0810] The terminal receives the summary and checklist sent from the server. The input is the data sent from the server, and the output is the display of the received summary and checklist. Specific operations use HTML, CSS, and JavaScript to display the received data on the screen.

[0811] Step 10:

[0812] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time. The input is the user's facial expressions and voice, and the output is emotional data as the analysis result. Specifically, it collects user data via a camera and microphone and uses analysis software to estimate the user's emotional state.

[0813] Step 11:

[0814] The terminal accepts the user's operation of checking each item on the checklist and pressing the consent button. The input is the user's operation, and the output is the checklist status and consent information. Specifically, the terminal accepts user input through a user interface.

[0815] Step 12:

[0816] The terminal sends the collected response data and emotion data to the server. The input is the user's response data and emotion data, and the output is transmission to the server. Specifically, the data is sent using the HTTP / HTTPS protocol.

[0817] Step 13:

[0818] The user checks the summary displayed on the terminal and checks the important items. The input is the summary and the checklist, and the output is the checked checklist. Specifically, the user reads each item and checks the necessary items.

[0819] Step 14:

[0820] After the user has checked all the check items, they press the Agree button. The input is the checked checklist, and the output is an expression of consent. Specifically, the user indicates consent by pressing the Agree button based on the items they have checked.

[0821] (Application example 2)

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

[0823] Conventional terms of service confirmation systems present users with lengthy, difficult-to-understand terms and conditions, making it difficult for them to efficiently review important parts and resulting in a poor user experience. Furthermore, in autonomous vehicles, if consent to the terms and conditions is not obtained quickly and reliably, it could affect safety and service quality. Furthermore, providing information uniformly without considering the user's emotional state can also cause problems, with some users being unable to accurately understand the content.

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

[0825] In this invention, the server includes means for converting the terms of use acquired from the service provider into text data, means for analyzing the converted text data and extracting important parts, means for generating a summary of the extracted important parts in plain language, means for selecting particularly important matters from the generated summary and creating a checklist, means for transmitting the generated summary and checklist to a user terminal, emotion recognition means for analyzing the user's emotions in real time in the user terminal to obtain user consent for the autonomously driving vehicle, and means for providing additional explanations according to the user's emotional state. This enables the user to confirm important matters of the terms of use in an easy-to-understand format, obtain consent quickly and reliably, and further enables flexible provision of information according to the user's emotional state.

[0826] "Service Provider" refers to a company or organization that offers a particular service or product.

[0827] "Terms of Use" refers to a document that lists the rules and conditions that users must follow when using a service.

[0828] "Text data" refers to information stored as character string data.

[0829] "Means for converting" refers to a method or device for converting data of one format into another format.

[0830] "Means for analysis" refers to methods and devices for analyzing data and understanding its contents.

[0831] "Important parts" refers to information or content that is particularly important within the whole.

[0832] "Plain writing" refers to writing that is easy to understand and simply written.

[0833] A "summary" is a sentence that summarizes a longer piece of text in a short form.

[0834] A "checklist" is a list of items to be checked.

[0835] "User terminal" refers to a device used by a user, including a personal computer or smartphone.

[0836] "Emotion recognition means" refers to a method or device for analyzing and understanding a user's emotions.

[0837] "Additional explanation" refers to an explanation added to supplement the original explanation.

[0838] "Agreement button" refers to a button that allows a user to indicate their consent to certain matters.

[0839] "Natural language processing technology" refers to the technology that uses computers to process and understand human language.

[0840] This invention is a system that optimizes the process for users of autonomous vehicles to confirm terms of use in an easy-to-understand manner and agree to important matters. This system consists of a server side and a terminal side, and the functions and processing methods of each are explained below.

[0841] Server-side processing

[0842] Obtaining rules and converting them to text data

[0843] The server retrieves the new terms of service from the service provider, usually as a PDF document, and uses the PyPDF2 library to extract the text data from the PDF file.

[0844] Text Preprocessing

[0845] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[0846] Parsing Terms

[0847] The server analyzes the preprocessed text using natural language processing (NLP) techniques, tokenizing the text and extracting important keywords and phrases using importance evaluation techniques such as TF-IDF, and then generates summaries for each important section using the BERT model.

[0848] Summary and checklist generation

[0849] Based on the analyzed important parts, the server generates a summary in plain language. This summary is generated according to pre-defined guidelines and templates and is provided in a format that is easy for users to understand. Particularly important points are selected from the generated summary to create a checklist.

[0850] Sending data

[0851] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0852] Terminal side processing

[0853] Receiving and displaying data

[0854] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[0855] Emotion recognition with emotion engine

[0856] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time to understand how the user is reacting to the information displayed.

[0857] Collecting user responses

[0858] The device accepts the user's operation of checking each check box and pressing the "Agree" button. It is also possible to further simplify the explanation or provide supplementary information depending on the user's emotional state.

[0859] Sending data

[0860] The device sends the user's responses (checklist status and consent information) and emotion data to the server using the HTTP / HTTPS protocol.

[0861] User operations

[0862] Check the terms and conditions

[0863] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[0864] Check the items

[0865] The user checks each item in the checklist, which lists particularly important matters in the terms of use.

[0866] consent

[0867] The user completes the checklist and checks the necessary items. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[0868] Specific examples and prompts for the generative AI model

[0869] As a concrete example, consider the procedure for getting into a self-driving car. Since many users find it tedious to read the service's terms of use all at once, the system presents important information succinctly and analyzes the user's emotional state to provide feedback, facilitating the consent process.

[0870] Example prompt sentence:

[0871] Your goal is to create a Python program that converts PDF-formatted terms of use into an easy-to-understand summary for users, and then obtains their consent to key terms. On the server side, you will use the PyPDF2 library to extract text and create a summary using the BERT model. On the device side, you will analyze user sentiment and manage the consent process.

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

[0873] Step 1:

[0874] The server receives the new terms of use in PDF format from the service provider. The input is a PDF document, which is saved on the server. The output is the PDF file itself.

[0875] Step 2:

[0876] The server extracts text data from a PDF file using the PyPDF2 library by opening the PDF file and getting the text from each page sequentially. The input is the PDF file, and the output is the extracted text data.

[0877] Step 3:

[0878] The server preprocesses the extracted text data. In this process, unnecessary line breaks, spaces, and special characters are removed from the text. The input is the extracted text data, and the output is the preprocessed, clean text data.

[0879] Step 4:

[0880] The server analyzes the preprocessed text data using natural language processing (NLP) techniques. This involves tokenizing the text and extracting important keywords and phrases using TF-IDF. It then generates summaries for each important section using the BERT model. The input is the preprocessed text data, and the output is important keywords and summary sentences.

[0881] Step 5:

[0882] The server generates a plain-language summary based on the key parts of the analysis. The summary is created according to pre-defined guidelines and templates. The input is key keywords and a draft summary, and the output is the final summary in a format that is easy for the user to understand.

[0883] Step 6:

[0884] The server selects particularly important items from the generated summary and creates a checklist. The input is the summary, and the output is a checklist that lists the particularly important items.

[0885] Step 7:

[0886] The server sends the generated summary and checklist to the user terminal via HTTP / HTTPS protocol. The input is the summary and checklist, and the output is the data sent to the user terminal.

[0887] Step 8:

[0888] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format. HTML, CSS, and JavaScript are used for display. The input is the summary and checklist sent from the server, and the output is the content displayed on the user's screen.

[0889] Step 9:

[0890] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time. The emotion engine analyzes how the user reacts to displayed information and grasps their emotional state. The input is the user's facial expressions and voice, and the output is analyzed emotional state data.

[0891] Step 10:

[0892] The device further simplifies the explanation or provides supplementary information according to the user's emotional state. The input is emotional state data, and the output is an explanation optimized according to the user's level of understanding and emotions.

[0893] Step 11:

[0894] The terminal accepts the user's operation of checking each check item and pressing the consent button. Based on the user's operation, the terminal collects the checklist status and consent information. The input is the user's operation, and the output is the collected user response data.

[0895] Step 12:

[0896] The terminal sends the collected response data and emotion data to the server using the HTTP / HTTPS protocol. The input is the user's response data and emotion data, and the output is the data sent to the server.

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

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

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

[0900] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0913] The present invention provides a system for providing the content of terms of use in a form that is easy for the user to understand and for confirming consent to important items. Specific embodiments for carrying out the present invention will be described below.

[0914] 1. Server-side processing

[0915] Obtaining the regulations and converting them into text data

[0916] The server obtains new terms of service from the service provider (e.g., "Service A Terms of Service.pdf"). These terms are usually in PDF format, and a library (e.g., PyPDF2) is used to convert them into text data.

[0917] Parsing Terms

[0918] The server analyzes the text data using natural language processing (NLP) techniques to identify key sections (e.g., terms of use, privacy, liability, etc.) and extract important keywords using tokenization, importance assessment (e.g., TF-IDF), and summarization techniques (e.g., the BERT model).

[0919] Summary generation

[0920] Based on the key parts of the analysis, the server generates a plain-language summary, which is generated according to pre-defined guidelines and templates and presented in a format that is easy for users to understand.

[0921] Creating a summary checklist

[0922] From the generated summary, particularly important points are selected and a checklist is created. The checklist includes important items that users must agree to (e.g., "You must be 18 years of age or older to use this service").

[0923] Sending data

[0924] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0925] 2. Terminal processing

[0926] Receiving and displaying data

[0927] The terminal receives the summary and checklist sent from the server, analyzes this data, and displays it in a user-friendly format using HTML, CSS, and JavaScript.

[0928] Collecting user responses

[0929] The terminal accepts the user's operation of checking each item on the checklist and pressing the "Agree" button. Information based on this operation is sent to the server.

[0930] Sending data

[0931] The device sends the user's response (checklist and consent history) to the server, which records the user's consent status and helps prevent problems.

[0932] 3. User Operation

[0933] Check the terms and conditions

[0934] The user checks the summary of the terms of use displayed on the device. The summary is concise and easy to understand, allowing the user to understand the content in a short amount of time.

[0935] Check the items

[0936] The user checks each item in the checklist, which lists the most important points in the terms of use and displays them in an easy-to-understand format.

[0937] consent

[0938] The user completes the checklist, checks the necessary items, and then presses the "Agree" button. This operation records that the user has agreed to the terms and conditions.

[0939] Specific examples

[0940] Server-side processing example

[0941] The server retrieves "Service A Terms of Use.pdf" and converts it to text data using the PyPDF2 library. Next, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It then uses the BERT model to generate a summary of the important sections and summarize them in plain text. It then selects important points and creates a checklist. Finally, it sends the summary and checklist to the user's device.

[0942] Example of terminal processing

[0943] The terminal receives the summary and checklist sent from the server, displays them on the screen, accepts the user's checkmarks on the checklist and presses the consent button, and sends the collected response data to the server.

[0944] User operation example

[0945] The user checks the summary displayed on the device, checks the important items, and after checking all the items, presses the "Agree" button to agree to the terms and conditions.

[0946] The processing flow will be explained below.

[0947] Server Processing

[0948] Step 1: Obtaining the terms and converting them to text data

[0949] The server retrieves the new terms of use from the service provider. This is usually a PDF document. The server uses a library (e.g., PyPDF2) to extract the text data from this PDF file.

[0950] Step 2: Preprocessing the text

[0951] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[0952] Step 3: Parsing the Terms

[0953] The server analyzes the preprocessed text using natural language processing (NLP) techniques.

[0954] The server tokenizes the text and splits it into sentences and phrases.

[0955] The server uses importance evaluation techniques such as TF-IDF to extract important keywords and phrases.

[0956] The server uses the BERT model to generate summaries for each important section.

[0957] Step 4: Generate a summary

[0958] The server then converts the summary generated from the analyzed key sections into plain text using pre-defined templates and guidelines, avoiding technical jargon and complex language to make it easier for users to understand.

[0959] Step 5: Create a summary checklist

[0960] The server selects particularly important points from the generated summary and creates a checklist, which contains important items that the user must agree to.

[0961] For example, generate an item in the form "■ You must be 18 years of age or older to use this service."

[0962] Step 6: Send the data

[0963] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[0964] Terminal handling

[0965] Step 1: Receiving and displaying data

[0966] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[0967] Step 2: Collect user responses

[0968] The terminal accepts the user's operation of checking each check item, and after the user has confirmed all items, accepts the user's pressing of the "Agree" button.

[0969] Step 3: Send the data

[0970] The terminal sends the user's response (checklist status and consent information) to the server using the HTTP / HTTPS protocol.

[0971] User operations

[0972] Step 1: Review the terms and conditions

[0973] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[0974] Step 2: Check the items

[0975] The user checks each item in the checklist, which lists particularly important matters in the terms of use.

[0976] Step 3: Accept

[0977] The user checks the checklist and checks each item. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[0978] Example 1

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

[0980] In today's world, many users find it difficult to understand the terms of service. Terms of service are usually lengthy and contain many technical terms and legal expressions, making it difficult for the average user to quickly and accurately grasp their content. Furthermore, there is a high risk of trouble or disputes arising due to insufficient confirmation of consent to important terms. There is a need for a system that can solve these issues and enable users to easily understand terms of service and properly consent to important terms.

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

[0982] In this invention, the server includes means for converting the terms of use obtained from the service provider into text data, means for analyzing the converted text data, identifying major sections, and extracting important keywords, means for generating a summary in plain language of the extracted important parts, means for selecting particularly important matters from the generated summary and creating a checklist, and means for transmitting the generated summary and checklist to a user terminal, thereby enabling the user to quickly understand the important contents of the terms of use and appropriately agree to particularly important items.

[0983] A "service provider" is an organization or individual that provides a service to a user.

[0984] "Terms of Use" means the document that sets out the terms, conditions and regulations for use of the Service.

[0985] "Text data" refers to data in which character information is expressed in digital form.

[0986] To "convert" means to change from one form or state to another.

[0987] "Analyzing" means breaking down data or information and clarifying its structure and meaning.

[0988] "Major sections" are parts or sections of a document that are particularly important.

[0989] "Important keywords" are words or phrases that are considered to be particularly important within a document.

[0990] "Simple writing" refers to writing written in simple, easy-to-understand language that is easy for anyone to understand.

[0991] A "summary" is a short sentence that succinctly summarizes the contents of a long document.

[0992] "To select" means to choose from among many things according to a criterion.

[0993] A "checklist" is a list of items to be checked or evaluated.

[0994] A "user terminal" refers to an electronic device such as a computer or smartphone used by a user.

[0995] "Natural language processing technology" refers to technology for processing human language using a computer.

[0996] The "BERT model" refers to a deep learning model transformed from a bidirectional encoder representation.

[0997] The present invention provides a system for providing the content of terms of use in a form that is easy for the user to understand and for confirming consent to important items. Specific embodiments for carrying out the present invention will be described below.

[0998] Server-side processing

[0999] The server first obtains the new terms of use (e.g., "Terms of Use.pdf") from the service provider. These terms are usually in PDF format, and a library (e.g., PyPDF2) is used to convert them into text data. The PyPDF2 library is used to convert the PDF document into text data.

[1000] The server then uses natural language processing (NLP) techniques to analyze the text data. This analysis process identifies major sections (e.g., terms of use, privacy, liability, etc.) and extracts important keywords. Analysis includes tokenization using the NLTK library, importance assessment using TF-IDF, and summarization using the BERT model.

[1001] Based on the analyzed important parts, the server generates a summary in plain language. This summary is generated according to pre-defined guidelines and templates and is provided in a format that is easy for the user to understand. Furthermore, it selects particularly important points from the generated summary and creates a checklist. The checklist contains important items that the user must agree to.

[1002] Finally, the server uses HTTP / HTTPS protocol to send the generated summary and checklist to the user terminal. In this transmission process, the data is usually encoded in JSON format.

[1003] Terminal side processing

[1004] The terminal receives the summary and checklist sent from the server, analyzes the received data using JavaScript, and displays it in a user-friendly format using HTML and CSS.

[1005] The device accepts the user's operation of checking each item on the checklist and pressing the "Agree" button. This operation information is then sent back to the server. This sending process uses the Fetch API to send the collected data to the server.

[1006] User operations

[1007] The user checks the summary of the terms of use displayed on the device. The summary is concise and easy to understand, allowing the user to understand the content in a short amount of time. The user then checks each item on the checklist and checks the necessary items. After checking all the items, the user presses the Agree button, which records their agreement to the terms of use.

[1008] Specific examples

[1009] Server-side processing example

[1010] The server retrieves the "Terms of Use.pdf" and converts it to text data using the PyPDF2 library. It then tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. Finally, it uses the BERT model to generate summaries of important sections and summarize them in plain text.

[1011] Example of terminal processing

[1012] The device receives the summary and checklist sent from the server, displays them on the screen using HTML and JavaScript, accepts the user's checkmarks on the checklist and clicks the consent button, and sends the collected response data to the server.

[1013] User operation example

[1014] The user checks the summary displayed on the device, checks the important items, and after checking all the items, presses the "Agree" button to agree to the terms and conditions.

[1015] Prompt Sentence Examples

[1016] "Write code to convert the new terms of use PDF document into text data, parse it, and generate a summary and checklist."

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

[1018] Step 1: Get the terms

[1019] The server obtains the new terms of use (e.g., "Terms of Use.pdf") from the service provider. The obtained PDF document is saved in the file system.

[1020] Input: Terms of use provided by the service provider in PDF format.

[1021] Output: PDF file saved on the server's file system.

[1022] Step 2: Convert PDF to text data

[1023] The server uses the PyPDF2 library to convert the PDF file into text data. Specifically, it uses the PdfFileReader class to extract the contents of each page into text.

[1024] Input: PDF file.

[1025] Output: The converted text data.

[1026] Step 3: Analyzing the text data

[1027] The server analyzes the text data using natural language processing (NLP) techniques. First, it uses the NLTK library to tokenize the text and split each word. Then it uses TF-IDF to extract important keywords and summarizes the main sections using the BERT model.

[1028] Input: Text data.

[1029] Output: Key keywords and a summary statement.

[1030] Step 4: Generate a summary

[1031] Based on the analysis, the server compiles a plain-language summary of the key points, which is formatted according to pre-defined guidelines and templates.

[1032] Input: Analysis results (important keywords, main sections).

[1033] Output: A plain text summary.

[1034] Step 5: Create a checklist

[1035] The server selects important points from the generated summary and creates a checklist, which includes items that the user must agree to.

[1036] Input: Abstract text.

[1037] Output: Checklist.

[1038] Step 6: Sending data

[1039] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol, with the data encoded in JSON format.

[1040] Input: Summary statement and checklist.

[1041] Output: Data sent to the user's terminal.

[1042] Step 7: Receive and display data

[1043] The terminal receives the summary and checklist sent from the server, analyzes the data, and displays it in a user-friendly format using HTML and JavaScript.

[1044] Input: The data sent by the server.

[1045] Output: On-screen summary and checklist.

[1046] Step 8: Collect user responses

[1047] The terminal accepts the user's operation of checking each item on the checklist and pressing the "Agree" button. This response information is temporarily stored in the terminal.

[1048] Input: User operation (checking and pressing the agree button).

[1049] Output: Collected response information.

[1050] Step 9: Sending the user's response

[1051] The device sends the collected user response information to the server, again using the Fetch API, with the data encoded in JSON format.

[1052] Input: Collected user response information.

[1053] Output: The data sent to the server.

[1054] Step 10: Record the user's agreement and consent

[1055] The server receives the response data sent from the terminal and records that the user has agreed to the terms and conditions, thereby managing the user's consent status.

[1056] Input: Response data sent from the terminal.

[1057] Output: User consent information recorded in a database.

[1058] (Application example 1)

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

[1060] The current way terms of use are presented is difficult for users to understand, and reading the lengthy terms is a hassle. As a result, users may miss important parts of the terms of use or fail to properly confirm their agreement. Furthermore, when the terms of use are changed, users are not notified promptly, making it difficult for them to know whether they have agreed to the latest terms. This increases the likelihood of disputes between service providers and users.

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

[1062] In this invention, the server includes means for converting the terms of use obtained from the service provider into text data, means for analyzing the converted text data and extracting important parts, means for detecting changes to the terms of use and sending a notification to the user terminal, means for selecting particularly important items from the generated summary and creating a checklist, and means for displaying the summary and checklist when the user taps the notification. This allows the important parts of the terms of use to be presented to the user in an easy-to-understand manner, enabling the user to quickly and reliably check important items.

[1063] "Service provider" refers to an institution or organization that provides a service.

[1064] "Terms of Use" refers to a document that stipulates the terms and conditions of use and restrictions of the Service.

[1065] "Means for converting to text data" refers to methods and tools for converting non-text data, such as PDFs and image files, into text format.

[1066] "Means of analyzing and extracting important parts" refers to techniques and methods for analyzing text data using natural language processing technology, etc., and selecting particularly important information from it.

[1067] "Means for generating a summary" refers to techniques or methods for generating concise sentences that are easy for users to understand based on analyzed data.

[1068] "Means for selecting particularly important items and creating a checklist" refers to techniques and methods for selecting items of high importance from the generated summary text and compiling them into a list.

[1069] "Means for transmitting to the user terminal" refers to the communication technology or method for transmitting the generated summary and checklist to the terminal used by the user.

[1070] "Means for detecting changes to the Terms of Use" refers to technologies or methods for automatically detecting changes to the Terms of Use.

[1071] "Means for sending notifications" refers to the technology or method for sending notifications to inform users of changes to the Terms of Use or important matters.

[1072] "Means for displaying the summary and checklist" refers to a technique or method for visually displaying the summary and checklist on a user terminal.

[1073] The present invention is a system that provides users with terms of use obtained from service providers in an easy-to-understand format and confirms their agreement with important items. The main components of this system are a server and a user terminal, and the roles of each are described in detail below.

[1074] Server-side processing

[1075] Obtaining the regulations and converting them into text data

[1076] The server obtains the new terms of use from the service provider. The terms of use are usually provided in PDF format, and to convert them into text data, a library such as PyPDF2 is used.

[1077] Parsing Terms

[1078] The server analyzes the text data using natural language processing (NLP) techniques to identify major sections and extract important keywords, using advanced summarization techniques such as the NLTK library, TF-IDF, and the BERT model.

[1079] Summary generation

[1080] Based on the key parts of the analysis, the server generates a summary in plain language. This summary is generated using a generative AI model (e.g., GPT-3) and provided in a format that is easy for users to understand.

[1081] Creating a summary checklist

[1082] Particularly important points are selected from the generated summary and a checklist is created, which contains important items that the user must agree to.

[1083] Sending data

[1084] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[1085] Detect changes to terms and conditions and send notifications

[1086] The server detects changes to the terms of use and sends push notifications to user devices accordingly, allowing users to quickly access the latest terms of use.

[1087] Terminal side processing

[1088] Receiving and displaying data

[1089] The user device receives the summary and checklist sent from the server and displays them on the screen using HTML, CSS, and JavaScript.

[1090] Collecting user responses

[1091] The user terminal accepts the user's operation of checking each item on the checklist and pressing the "agree" button. Information based on this operation is sent to the server.

[1092] Sending data

[1093] The user device sends the user's response data (checklist and consent history) to the server, which records the user's consent status and helps prevent problems.

[1094] User operations

[1095] Check the terms and conditions

[1096] The user checks the summary of the terms of use displayed on the device. The summary is concise and easy to understand, allowing the user to understand the content in a short amount of time.

[1097] Check the items

[1098] The user checks each item in the checklist, which lists the most important points in the terms of use and displays them in an easy-to-understand format.

[1099] consent

[1100] The user completes the checklist, checks the necessary items, and then presses the "Agree" button. This operation records that the user has agreed to the terms and conditions.

[1101] Specific examples

[1102] For example, when a shopping site publishes new terms of use, users are notified with a prompt like this:

[1103] The new Terms of Use have been published. To review the contents, please open the "Easy Terms of Use Checker" and check the summary and checklist. You must agree to all important items.

[1104] Users can tap the notification to open the app, review the summary and checklist, and agree to the contents to prevent any problems with the service provider.

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

[1106] Step 1:

[1107] The server obtains new terms of use from the service provider. The obtained terms of use are usually in PDF format, and are converted to text data using, for example, the PyPDF2 library. The input is a PDF file, and the output is text data. Converting it to text data makes it easier to analyze later.

[1108] Step 2:

[1109] The server analyzes the converted text data using natural language processing (NLP) techniques. Specifically, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It also summarizes important sections using the BERT model. The input is text data, and the output is important keywords and summaries. This analysis effectively extracts the most important parts of the terms.

[1110] Step 3:

[1111] The server generates a summary in simple language based on the analyzed key parts. The summary is created using a generative AI model (e.g., GPT-3). The input is the analysis result, and the output is a summary that is easy for users to understand. This summary is easy for users to understand, allowing them to grasp the important content in a short amount of time.

[1112] Step 4:

[1113] The server selects particularly important items from the generated summary and creates a checklist. Pre-defined importance criteria are used to create the checklist. The input is the summary, and a checklist containing important items is generated as output. Using this checklist makes it easier for users to check particularly important items.

[1114] Step 5:

[1115] The server sends the generated summary and checklist to the user's terminal. The HTTP / HTTPS protocol is used for transmission. The input is the summary and checklist, and the output is a notification of completion of transmission. By receiving this, the user can confirm important parts of the terms and conditions.

[1116] Step 6:

[1117] The server detects changes to the terms of use and sends a notification to the user's device based on the changes. A change detection algorithm is used to detect changes. The input is the difference information between the old and new terms of use, and the output is a notification message. This notification allows the user to quickly obtain the latest terms of use information.

[1118] Step 7:

[1119] The user checks the summary of the terms of use displayed on the terminal and confirms each item on the checklist. The user checks each item on the checklist and presses the "Agree" button. This input action generates consent confirmation information as output. This consent confirmation information is sent to the server, and the user's consent status is appropriately recorded.

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

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

[1122] The present invention is a system that provides the content of terms of use in a form that is easy for the user to understand, confirms consent to important items, and further combines it with an emotion engine for recognizing the user's emotions. Specific embodiments for carrying out the present invention will be described below.

[1123] 1. Server-side processing

[1124] Obtaining the regulations and converting them into text data

[1125] The server retrieves the new terms of use from the service provider. This is usually a PDF document. The server uses a library (e.g., PyPDF2) to extract the text data from this PDF file.

[1126] Text Preprocessing

[1127] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[1128] Parsing Terms

[1129] The server analyzes the preprocessed text using natural language processing (NLP) techniques.

[1130] The server tokenizes the text and splits it into sentences and phrases.

[1131] The server uses importance evaluation techniques such as TF-IDF to extract important keywords and phrases.

[1132] The server uses the BERT model to generate summaries for each important section.

[1133] Summary generation

[1134] Based on the key parts of the analysis, the server generates a plain-language summary, which is generated according to pre-defined guidelines and templates and presented in a format that is easy for users to understand.

[1135] Creating a summary checklist

[1136] The server selects the most important points from the generated summary and creates a checklist containing important items that the user must agree to.

[1137] For example, generate an item in the form "■ You must be 18 years of age or older to use this service."

[1138] Sending data

[1139] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[1140] 2. Terminal processing

[1141] Receiving and displaying data

[1142] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[1143] Emotion recognition with emotion engine

[1144] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time to understand how the user is reacting to the information displayed.

[1145] Collecting user responses

[1146] The device accepts the user's operation of checking each check box and pressing the "Agree" button. Depending on the user's emotional state, it is possible to further simplify the explanation or provide supplementary information.

[1147] Sending data

[1148] The device sends the user's responses (checklist status and consent information) and emotion data to the server using the HTTP / HTTPS protocol.

[1149] 3. User Operation

[1150] Check the terms and conditions

[1151] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[1152] Check the items

[1153] The user checks each item in the checklist, which lists particularly important matters in the terms of use.

[1154] consent

[1155] The user completes the checklist and checks the necessary items. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[1156] Specific examples

[1157] Server-side processing example

[1158] The server retrieves "Service A Terms of Use.pdf" and converts it into text data using the PyPDF2 library. Next, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It then uses the BERT model to generate a summary of the important sections and summarize them in plain text. It selects important points and creates a checklist. Finally, it sends the summary and checklist to the user's device.

[1159] Example of terminal processing

[1160] The device receives the summary and checklist sent from the server and displays them on the screen. It uses an emotion engine to analyze the user's facial expressions and voice and provides feedback according to the user's emotional state. When the user checks the checkboxes and presses the consent button, the collected response data and emotional data are sent to the server.

[1161] User operation example

[1162] The user checks the summary displayed on the device and ticks the important points. After checking all the check items, taking into consideration the feedback analyzed by the emotion engine, the user presses the "Agree" button. This indicates consent to the terms and conditions, and this consent is recorded.

[1163] The processing flow will be explained below.

[1164] Server Processing

[1165] Step 1: Obtaining the terms and converting them to text data

[1166] The server retrieves the new terms of use from the service provider. This is usually a PDF document. The server uses a library (e.g., PyPDF2) to extract the text data from this PDF file.

[1167] Step 2: Preprocessing the text

[1168] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[1169] Step 3: Parsing the Terms

[1170] The server analyzes the preprocessed text using natural language processing (NLP) techniques. Specifically, it performs the following operations:

[1171] The server tokenizes the text and splits it into sentences and phrases.

[1172] The server uses importance evaluation techniques such as TF-IDF to extract important keywords and phrases.

[1173] The server uses the BERT model to generate summaries for each important section.

[1174] Step 4: Generate a summary

[1175] The server generates a summary in plain language based on the key parts of the analysis, using pre-defined templates and guidelines to avoid technical jargon and difficult expressions and make the summary easy for users to understand.

[1176] Step 5: Create a summary checklist

[1177] The server selects particularly important points from the generated summary and creates a checklist. The checklist contains important items that the user must agree to. For example, it generates items in a specific format such as "■ You must be 18 years of age or older to use this service."

[1178] Step 6: Send the data

[1179] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[1180] Terminal handling

[1181] Step 1: Receiving and displaying data

[1182] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[1183] Step 2: Emotion recognition by the emotion engine

[1184] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time to understand how the user is reacting to the information displayed.

[1185] Step 3: Provide feedback

[1186] The device provides appropriate feedback to the user based on the analysis results obtained from the emotion engine. If the user's level of understanding is low, the device may display a more concise explanation or provide additional information.

[1187] Step 4: Collect user responses

[1188] The terminal accepts the user's operation to check each check item, and after the user has confirmed all items, accepts the user's press of the consent button.

[1189] Step 5: Send the data

[1190] The device sends the user's responses (checklist status and consent information) and emotion data to the server using the HTTP / HTTPS protocol.

[1191] User operations

[1192] Step 1: Review the terms and conditions

[1193] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[1194] Step 2: Check the items

[1195] The user checks each item on the checklist, which lists the most important points in the terms of use.

[1196] Step 3: Accept

[1197] The user checks the checklist and checks each item. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[1198] Example 2

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

[1200] In today's world, with many services being provided online, terms of use are important, legally binding documents. However, these documents are often lengthy and full of technical terms, which creates a problem: many users agree to the terms without fully understanding them. It is also difficult to verify whether users actually agree to the terms. Furthermore, understanding the emotional state of users when they agree is crucial, but current systems are unable to address this issue.

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

[1202] In this invention, the server includes: means for converting terms of use obtained from a service provider into text data; means for normalizing unnecessary spaces, line breaks, and special characters from the converted text data; means for analyzing the converted and normalized text data and extracting important parts; means for generating a summary of the extracted important parts in plain language; means for selecting particularly important matters from the generated summary and creating a checklist; means for transmitting the generated summary and checklist to a user terminal; and means including an emotion engine for analyzing the user's emotional state. This allows the user to easily understand the contents of the terms of use and reliably obtain consent to important matters. Furthermore, analyzing the user's emotional state enables further feedback and adaptive responses.

[1203] "Service Provider" refers to a legal entity or individual that provides a particular service to a User.

[1204] "Terms of Use" refers to a document that describes the terms and rules of use for the services provided by a service provider.

[1205] "Means for converting to text data" refers to technology or methods for converting document formats such as PDF into text format.

[1206] "Normalization" refers to the process of systematically organizing and removing unnecessary spaces, line breaks, and special characters to maintain data consistency.

[1207] "Analysis" refers to the process of analyzing text data using natural language processing and other techniques to extract meaning and important information.

[1208] "Tokenization" refers to the process of breaking text into smaller units such as words, sentences, or phrases.

[1209] "Important parts" refers to sections or keywords in the Terms of Use that are deemed to be particularly important to users.

[1210] A "summary" is a short document that extracts important information from the original text and summarizes it in simple language.

[1211] A "checklist" is a document that lists important items and things that need to be checked.

[1212] "User terminal" refers to a device such as a smartphone, tablet, or PC that a user uses to access the service.

[1213] An "emotion engine" is a technology that analyzes a user's facial expressions and voice, and refers to a system for estimating the user's emotional state.

[1214] This invention is a system that provides users with terms of use in an easy-to-understand format, confirms their agreement to important items, and combines an emotion engine to recognize the user's emotions. This system operates in cooperation with the server, terminal, and user elements.

[1215] Server-side processing

[1216] The server first obtains the new terms of use from the service provider. This is usually a PDF document. The server uses software to convert the document to text data, such as the PyPDF2 library. The server uses this library to extract the text data from the PDF file.

[1217] The extracted text data is difficult to analyze as is, so unnecessary spaces, line breaks, and special characters are normalized. This is done using regular expression processing, etc. The server then analyzes the normalized text data using natural language processing (NLP) techniques. For example, this analysis involves tokenizing the text using the NLTK library and extracting important keywords using TF-IDF techniques.

[1218] The server then uses a generative AI model, such as the BERT model, to generate a summary of each important section. This summary is then written in plain language, making it easy for users to understand. The server then selects the most important points from the summary and creates a checklist, which includes key items that users should agree to.

[1219] Finally, the server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[1220] Terminal side processing

[1221] The device receives the summary and checklist sent from the server and displays them in a user-friendly format. This display uses HTML, CSS, and JavaScript. Furthermore, the device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time. This emotion engine, which uses OpenCV and TensorFlow, for example, to understand how the user is reacting to the displayed information.

[1222] The device also accepts the user's operation of checking checklist items and pressing the "Agree" button. Depending on the user's emotional state, the device can further simplify the explanation or provide additional supplementary information. The device then transmits the collected response data and emotional data to the server.

[1223] User operations

[1224] The user checks the summary of the terms of use displayed on the device. The summary is written in simple language so that the content can be understood in a short time. Next, the user checks each item on the checklist and checks the necessary items. After checking all the items, the user presses the "Agree" button to agree to the terms of use. This records the user's agreement.

[1225] Specific examples

[1226] The server retrieves "Service A Terms of Use.pdf" and converts it into text data using the PyPDF2 library. Next, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It then uses the BERT model to generate a summary of the important sections and summarize them in plain text. It selects important points and creates a checklist. Finally, it sends the summary and checklist to the user's device.

[1227] The device receives the summary and checklist sent from the server and displays them on the screen. It uses an emotion engine (e.g., OpenCV or TensorFlow) to analyze the user's facial expressions and voice and provide feedback according to the user's emotional state. When the user checks the checkboxes and presses the consent button, the collected response data and emotional data are sent to the server.

[1228] The user checks the summary displayed on the device and ticks the important points. After checking all the check items, taking into consideration the feedback analyzed by the emotion engine, the user presses the "Agree" button. This indicates consent to the terms and conditions, and this consent is recorded.

[1229] Prompt Sentence Examples

[1230] "What library will the server use to extract text data from PDF files? And what technique will it use to extract important keywords?"

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

[1232] Step 1:

[1233] The server obtains a PDF file of the terms of use (e.g., "ServiceATermsOfUse.pdf") from the service provider. The obtained PDF file is saved in a specific directory on the server. The input for this step is "ServiceATermsOfUse.pdf", and the output is the PDF file saved in the specified directory on the server.

[1234] Step 2:

[1235] The server uses the PyPDF2 library to extract text data from PDF files. It receives a PDF file as input and obtains text data as output. Specifically, it opens the PDF file and extracts text from each page sequentially. This process converts the contents of "Service A Terms of Use.pdf" into pure text data.

[1236] Step 3:

[1237] The server normalizes the extracted text data to remove unnecessary whitespace, line breaks, and special characters. The input is the extracted raw text data, and the output is the normalized, clean text data. Specifically, it uses regular expressions to remove unnecessary whitespace and line breaks and format the text into a consistent format.

[1238] Step 4:

[1239] The server analyzes the normalized text data using natural language processing (NLP) techniques. First, it tokenizes the text using the NLTK library. The input is normalized text data, and the output is tokenized text. Specifically, it splits the text into words, sentences, and phrases.

[1240] Step 5:

[1241] The server extracts important keywords and phrases using TF-IDF technology. The input is tokenized text data, and the output is a list of important keywords and phrases. Specifically, it calculates the frequency of occurrence of each word or phrase and evaluates its importance.

[1242] Step 6:

[1243] The server uses a generative AI model, such as the BERT model, to generate summaries for each key section. The input is text data containing important keywords and phrases, and the output is a summary. Specifically, the server analyzes the text using a pre-trained BERT model and generates a summary.

[1244] Step 7:

[1245] The server selects particularly important items from the generated summary and creates a checklist. The input is the summary, and the output is the checklist. Specifically, the server evaluates the summary and extracts important items that the user should check.

[1246] Step 8:

[1247] The server sends the generated summary and checklist to the user terminal. The input is the summary and checklist, and the output is transmission to the user terminal. Specifically, the data is sent using the HTTP / HTTPS protocol.

[1248] Step 9:

[1249] The terminal receives the summary and checklist sent from the server. The input is the data sent from the server, and the output is the display of the received summary and checklist. Specific operations use HTML, CSS, and JavaScript to display the received data on the screen.

[1250] Step 10:

[1251] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time. The input is the user's facial expressions and voice, and the output is emotional data as the analysis result. Specifically, it collects user data via a camera and microphone and uses analysis software to estimate the user's emotional state.

[1252] Step 11:

[1253] The terminal accepts the user's operation of checking each item on the checklist and pressing the consent button. The input is the user's operation, and the output is the checklist status and consent information. Specifically, the terminal accepts user input through a user interface.

[1254] Step 12:

[1255] The terminal sends the collected response data and emotion data to the server. The input is the user's response data and emotion data, and the output is transmission to the server. Specifically, the data is sent using the HTTP / HTTPS protocol.

[1256] Step 13:

[1257] The user checks the summary displayed on the terminal and checks the important items. The input is the summary and the checklist, and the output is the checked checklist. Specifically, the user reads each item and checks the necessary items.

[1258] Step 14:

[1259] After the user has checked all the check items, they press the Agree button. The input is the checked checklist, and the output is an expression of consent. Specifically, the user indicates consent by pressing the Agree button based on the items they have checked.

[1260] (Application example 2)

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

[1262] Conventional terms of service confirmation systems present users with lengthy, difficult-to-understand terms and conditions, making it difficult for them to efficiently review important parts and resulting in a poor user experience. Furthermore, in autonomous vehicles, if consent to the terms and conditions is not obtained quickly and reliably, it could affect safety and service quality. Furthermore, providing information uniformly without considering the user's emotional state can also cause problems, with some users being unable to accurately understand the content.

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

[1264] In this invention, the server includes means for converting the terms of use acquired from the service provider into text data, means for analyzing the converted text data and extracting important parts, means for generating a summary of the extracted important parts in plain language, means for selecting particularly important matters from the generated summary and creating a checklist, means for transmitting the generated summary and checklist to a user terminal, emotion recognition means for analyzing the user's emotions in real time in the user terminal to obtain user consent for the autonomously driving vehicle, and means for providing additional explanations according to the user's emotional state. This enables the user to confirm important matters of the terms of use in an easy-to-understand format, obtain consent quickly and reliably, and further enables flexible provision of information according to the user's emotional state.

[1265] "Service Provider" refers to a company or organization that offers a particular service or product.

[1266] "Terms of Use" refers to a document that lists the rules and conditions that users must follow when using a service.

[1267] "Text data" refers to information stored as character string data.

[1268] "Means for converting" refers to a method or device for converting data of one format into another format.

[1269] "Means for analysis" refers to methods and devices for analyzing data and understanding its contents.

[1270] "Important parts" refers to information or content that is particularly important within the whole.

[1271] "Plain writing" refers to writing that is easy to understand and simply written.

[1272] A "summary" is a sentence that summarizes a longer piece of text in a short form.

[1273] A "checklist" is a list of items to be checked.

[1274] "User terminal" refers to a device used by a user, including a personal computer or smartphone.

[1275] "Emotion recognition means" refers to a method or device for analyzing and understanding a user's emotions.

[1276] "Additional explanation" refers to an explanation added to supplement the original explanation.

[1277] "Agreement button" refers to a button that allows a user to indicate their consent to certain matters.

[1278] "Natural language processing technology" refers to the technology that uses computers to process and understand human language.

[1279] This invention is a system that optimizes the process for users of autonomous vehicles to confirm terms of use in an easy-to-understand manner and agree to important matters. This system consists of a server side and a terminal side, and the functions and processing methods of each are explained below.

[1280] Server-side processing

[1281] Obtaining rules and converting them to text data

[1282] The server retrieves the new terms of service from the service provider, usually as a PDF document, and uses the PyPDF2 library to extract the text data from the PDF file.

[1283] Text Preprocessing

[1284] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[1285] Parsing Terms

[1286] The server analyzes the preprocessed text using natural language processing (NLP) techniques, tokenizing the text and extracting important keywords and phrases using importance evaluation techniques such as TF-IDF, and then generates summaries for each important section using the BERT model.

[1287] Summary and checklist generation

[1288] Based on the analyzed important parts, the server generates a summary in plain language. This summary is generated according to pre-defined guidelines and templates and is provided in a format that is easy for users to understand. Particularly important points are selected from the generated summary to create a checklist.

[1289] Sending data

[1290] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[1291] Terminal side processing

[1292] Receiving and displaying data

[1293] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[1294] Emotion recognition with emotion engine

[1295] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time to understand how the user is reacting to the information displayed.

[1296] Collecting user responses

[1297] The device accepts the user's operation of checking each check box and pressing the "Agree" button. It is also possible to further simplify the explanation or provide supplementary information depending on the user's emotional state.

[1298] Sending data

[1299] The device sends the user's responses (checklist status and consent information) and emotion data to the server using the HTTP / HTTPS protocol.

[1300] User operations

[1301] Check the terms and conditions

[1302] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[1303] Check the items

[1304] The user checks each item in the checklist, which lists particularly important matters in the terms of use.

[1305] consent

[1306] The user completes the checklist and checks the necessary items. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[1307] Specific examples and prompts for the generative AI model

[1308] As a concrete example, consider the procedure for getting into a self-driving car. Since many users find it tedious to read the service's terms of use all at once, the system presents important information succinctly and analyzes the user's emotional state to provide feedback, facilitating the consent process.

[1309] Example prompt sentence:

[1310] Your goal is to create a Python program that converts PDF-formatted terms of use into an easy-to-understand summary for users, and then obtains their consent to key terms. On the server side, you will use the PyPDF2 library to extract text and create a summary using the BERT model. On the device side, you will analyze user sentiment and manage the consent process.

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

[1312] Step 1:

[1313] The server receives the new terms of use in PDF format from the service provider. The input is a PDF document, which is saved on the server. The output is the PDF file itself.

[1314] Step 2:

[1315] The server extracts text data from a PDF file using the PyPDF2 library by opening the PDF file and getting the text from each page sequentially. The input is the PDF file, and the output is the extracted text data.

[1316] Step 3:

[1317] The server preprocesses the extracted text data. In this process, unnecessary line breaks, spaces, and special characters are removed from the text. The input is the extracted text data, and the output is the preprocessed, clean text data.

[1318] Step 4:

[1319] The server analyzes the preprocessed text data using natural language processing (NLP) techniques. This involves tokenizing the text and extracting important keywords and phrases using TF-IDF. It then generates summaries for each important section using the BERT model. The input is the preprocessed text data, and the output is important keywords and summary sentences.

[1320] Step 5:

[1321] The server generates a plain-language summary based on the key parts of the analysis. The summary is created according to pre-defined guidelines and templates. The input is key keywords and a draft summary, and the output is the final summary in a format that is easy for the user to understand.

[1322] Step 6:

[1323] The server selects particularly important items from the generated summary and creates a checklist. The input is the summary, and the output is a checklist that lists the particularly important items.

[1324] Step 7:

[1325] The server sends the generated summary and checklist to the user terminal via HTTP / HTTPS protocol. The input is the summary and checklist, and the output is the data sent to the user terminal.

[1326] Step 8:

[1327] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format. HTML, CSS, and JavaScript are used for display. The input is the summary and checklist sent from the server, and the output is the content displayed on the user's screen.

[1328] Step 9:

[1329] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time. The emotion engine analyzes how the user reacts to displayed information and grasps their emotional state. The input is the user's facial expressions and voice, and the output is analyzed emotional state data.

[1330] Step 10:

[1331] The device further simplifies the explanation or provides supplementary information according to the user's emotional state. The input is emotional state data, and the output is an explanation optimized according to the user's level of understanding and emotions.

[1332] Step 11:

[1333] The terminal accepts the user's operation of checking each check item and pressing the consent button. Based on the user's operation, the terminal collects the checklist status and consent information. The input is the user's operation, and the output is the collected user response data.

[1334] Step 12:

[1335] The terminal sends the collected response data and emotion data to the server using the HTTP / HTTPS protocol. The input is the user's response data and emotion data, and the output is the data sent to the server.

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

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

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

[1339] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1353] The present invention provides a system for providing the content of terms of use in a form that is easy for the user to understand and for confirming consent to important items. Specific embodiments for carrying out the present invention will be described below.

[1354] 1. Server-side processing

[1355] Obtaining the regulations and converting them into text data

[1356] The server obtains new terms of service from the service provider (e.g., "Service A Terms of Service.pdf"). These terms are usually in PDF format, and a library (e.g., PyPDF2) is used to convert them into text data.

[1357] Parsing Terms

[1358] The server analyzes the text data using natural language processing (NLP) techniques to identify key sections (e.g., terms of use, privacy, liability, etc.) and extract important keywords using tokenization, importance assessment (e.g., TF-IDF), and summarization techniques (e.g., the BERT model).

[1359] Summary generation

[1360] Based on the key parts of the analysis, the server generates a plain-language summary, which is generated according to pre-defined guidelines and templates and presented in a format that is easy for users to understand.

[1361] Creating a summary checklist

[1362] From the generated summary, particularly important points are selected and a checklist is created. The checklist includes important items that users must agree to (e.g., "You must be 18 years of age or older to use this service").

[1363] Sending data

[1364] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[1365] 2. Terminal processing

[1366] Receiving and displaying data

[1367] The terminal receives the summary and checklist sent from the server, analyzes this data, and displays it in a user-friendly format using HTML, CSS, and JavaScript.

[1368] Collecting user responses

[1369] The terminal accepts the user's operation of checking each item on the checklist and pressing the "Agree" button. Information based on this operation is sent to the server.

[1370] Sending data

[1371] The device sends the user's response (checklist and consent history) to the server, which records the user's consent status and helps prevent problems.

[1372] 3. User Operation

[1373] Check the terms and conditions

[1374] The user checks the summary of the terms of use displayed on the device. The summary is concise and easy to understand, allowing the user to understand the content in a short amount of time.

[1375] Check the items

[1376] The user checks each item in the checklist, which lists the most important points in the terms of use and displays them in an easy-to-understand format.

[1377] consent

[1378] The user completes the checklist, checks the necessary items, and then presses the "Agree" button. This operation records that the user has agreed to the terms and conditions.

[1379] Specific examples

[1380] Server-side processing example

[1381] The server retrieves "Service A Terms of Use.pdf" and converts it to text data using the PyPDF2 library. Next, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It then uses the BERT model to generate a summary of the important sections and summarize them in plain text. It then selects important points and creates a checklist. Finally, it sends the summary and checklist to the user's device.

[1382] Example of terminal processing

[1383] The terminal receives the summary and checklist sent from the server, displays them on the screen, accepts the user's checkmarks on the checklist and presses the consent button, and sends the collected response data to the server.

[1384] User operation example

[1385] The user checks the summary displayed on the device, checks the important items, and after checking all the items, presses the "Agree" button to agree to the terms and conditions.

[1386] The processing flow will be explained below.

[1387] Server Processing

[1388] Step 1: Obtaining the terms and converting them to text data

[1389] The server retrieves the new terms of use from the service provider. This is usually a PDF document. The server uses a library (e.g., PyPDF2) to extract the text data from this PDF file.

[1390] Step 2: Preprocessing the text

[1391] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[1392] Step 3: Parsing the Terms

[1393] The server analyzes the preprocessed text using natural language processing (NLP) techniques.

[1394] The server tokenizes the text and splits it into sentences and phrases.

[1395] The server uses importance evaluation techniques such as TF-IDF to extract important keywords and phrases.

[1396] The server uses the BERT model to generate summaries for each important section.

[1397] Step 4: Generate a summary

[1398] The server then converts the summary generated from the analyzed key sections into plain text using pre-defined templates and guidelines, avoiding technical jargon and complex language to make it easier for users to understand.

[1399] Step 5: Create a summary checklist

[1400] The server selects particularly important points from the generated summary and creates a checklist, which contains important items that the user must agree to.

[1401] For example, generate an item in the form "■ You must be 18 years of age or older to use this service."

[1402] Step 6: Send the data

[1403] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[1404] Terminal handling

[1405] Step 1: Receiving and displaying data

[1406] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[1407] Step 2: Collect user responses

[1408] The terminal accepts the user's operation of checking each check item, and after the user has confirmed all items, accepts the user's pressing of the "Agree" button.

[1409] Step 3: Send the data

[1410] The terminal sends the user's response (checklist status and consent information) to the server using the HTTP / HTTPS protocol.

[1411] User operations

[1412] Step 1: Review the terms and conditions

[1413] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[1414] Step 2: Check the items

[1415] The user checks each item in the checklist, which lists particularly important matters in the terms of use.

[1416] Step 3: Accept

[1417] The user checks the checklist and checks each item. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[1418] Example 1

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

[1420] In today's world, many users find it difficult to understand the terms of service. Terms of service are usually lengthy and contain many technical terms and legal expressions, making it difficult for the average user to quickly and accurately grasp their content. Furthermore, there is a high risk of trouble or disputes arising due to insufficient confirmation of consent to important terms. There is a need for a system that can solve these issues and enable users to easily understand terms of service and properly consent to important terms.

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

[1422] In this invention, the server includes means for converting the terms of use obtained from the service provider into text data, means for analyzing the converted text data, identifying major sections, and extracting important keywords, means for generating a summary in plain language of the extracted important parts, means for selecting particularly important matters from the generated summary and creating a checklist, and means for transmitting the generated summary and checklist to a user terminal, thereby enabling the user to quickly understand the important contents of the terms of use and appropriately agree to particularly important items.

[1423] A "service provider" is an organization or individual that provides a service to a user.

[1424] "Terms of Use" means the document that sets out the terms, conditions and regulations for use of the Service.

[1425] "Text data" refers to data in which character information is expressed in digital form.

[1426] To "convert" means to change from one form or state to another.

[1427] "Analyzing" means breaking down data or information and clarifying its structure and meaning.

[1428] "Major sections" are parts or sections of a document that are particularly important.

[1429] "Important keywords" are words or phrases that are considered to be particularly important within a document.

[1430] "Simple writing" refers to writing written in simple, easy-to-understand language that is easy for anyone to understand.

[1431] A "summary" is a short sentence that succinctly summarizes the contents of a long document.

[1432] "To select" means to choose from among many things according to a criterion.

[1433] A "checklist" is a list of items to be checked or evaluated.

[1434] A "user terminal" refers to an electronic device such as a computer or smartphone used by a user.

[1435] "Natural language processing technology" refers to technology for processing human language using a computer.

[1436] The "BERT model" refers to a deep learning model transformed from a bidirectional encoder representation.

[1437] The present invention provides a system for providing the content of terms of use in a form that is easy for the user to understand and for confirming consent to important items. Specific embodiments for carrying out the present invention will be described below.

[1438] Server-side processing

[1439] The server first obtains the new terms of use (e.g., "Terms of Use.pdf") from the service provider. These terms are usually in PDF format, and a library (e.g., PyPDF2) is used to convert them into text data. The PyPDF2 library is used to convert the PDF document into text data.

[1440] The server then uses natural language processing (NLP) techniques to analyze the text data. This analysis process identifies major sections (e.g., terms of use, privacy, liability, etc.) and extracts important keywords. Analysis includes tokenization using the NLTK library, importance assessment using TF-IDF, and summarization using the BERT model.

[1441] Based on the analyzed important parts, the server generates a summary in plain language. This summary is generated according to pre-defined guidelines and templates and is provided in a format that is easy for the user to understand. Furthermore, it selects particularly important points from the generated summary and creates a checklist. The checklist contains important items that the user must agree to.

[1442] Finally, the server uses HTTP / HTTPS protocol to send the generated summary and checklist to the user terminal. In this transmission process, the data is usually encoded in JSON format.

[1443] Terminal side processing

[1444] The terminal receives the summary and checklist sent from the server, analyzes the received data using JavaScript, and displays it in a user-friendly format using HTML and CSS.

[1445] The device accepts the user's operation of checking each item on the checklist and pressing the "Agree" button. This operation information is then sent back to the server. This sending process uses the Fetch API to send the collected data to the server.

[1446] User operations

[1447] The user checks the summary of the terms of use displayed on the device. The summary is concise and easy to understand, allowing the user to understand the content in a short amount of time. The user then checks each item on the checklist and checks the necessary items. After checking all the items, the user presses the Agree button, which records their agreement to the terms of use.

[1448] Specific examples

[1449] Server-side processing example

[1450] The server retrieves the "Terms of Use.pdf" and converts it to text data using the PyPDF2 library. It then tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. Finally, it uses the BERT model to generate summaries of important sections and summarize them in plain text.

[1451] Example of terminal processing

[1452] The device receives the summary and checklist sent from the server, displays them on the screen using HTML and JavaScript, accepts the user's checkmarks on the checklist and clicks the consent button, and sends the collected response data to the server.

[1453] User operation example

[1454] The user checks the summary displayed on the device, checks the important items, and after checking all the items, presses the "Agree" button to agree to the terms and conditions.

[1455] Prompt Sentence Examples

[1456] "Write code to convert the new terms of use PDF document into text data, parse it, and generate a summary and checklist."

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

[1458] Step 1: Get the terms

[1459] The server obtains the new terms of use (e.g., "Terms of Use.pdf") from the service provider. The obtained PDF document is saved in the file system.

[1460] Input: Terms of use provided by the service provider in PDF format.

[1461] Output: PDF file saved on the server's file system.

[1462] Step 2: Convert PDF to text data

[1463] The server uses the PyPDF2 library to convert the PDF file into text data. Specifically, it uses the PdfFileReader class to extract the contents of each page into text.

[1464] Input: PDF file.

[1465] Output: The converted text data.

[1466] Step 3: Analyzing the text data

[1467] The server analyzes the text data using natural language processing (NLP) techniques. First, it uses the NLTK library to tokenize the text and split each word. Then it uses TF-IDF to extract important keywords and summarizes the main sections using the BERT model.

[1468] Input: Text data.

[1469] Output: Key keywords and a summary statement.

[1470] Step 4: Generate a summary

[1471] Based on the analysis, the server compiles a plain-language summary of the key points, which is formatted according to pre-defined guidelines and templates.

[1472] Input: Analysis results (important keywords, main sections).

[1473] Output: A plain text summary.

[1474] Step 5: Create a checklist

[1475] The server selects important points from the generated summary and creates a checklist, which includes items that the user must agree to.

[1476] Input: Abstract text.

[1477] Output: Checklist.

[1478] Step 6: Sending data

[1479] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol, with the data encoded in JSON format.

[1480] Input: Summary statement and checklist.

[1481] Output: Data sent to the user's terminal.

[1482] Step 7: Receive and display data

[1483] The terminal receives the summary and checklist sent from the server, analyzes the data, and displays it in a user-friendly format using HTML and JavaScript.

[1484] Input: The data sent by the server.

[1485] Output: On-screen summary and checklist.

[1486] Step 8: Collect user responses

[1487] The terminal accepts the user's operation of checking each item on the checklist and pressing the "Agree" button. This response information is temporarily stored in the terminal.

[1488] Input: User operation (checking and pressing the agree button).

[1489] Output: Collected response information.

[1490] Step 9: Sending the user's response

[1491] The device sends the collected user response information to the server, again using the Fetch API, with the data encoded in JSON format.

[1492] Input: Collected user response information.

[1493] Output: The data sent to the server.

[1494] Step 10: Record the user's agreement and consent

[1495] The server receives the response data sent from the terminal and records that the user has agreed to the terms and conditions, thereby managing the user's consent status.

[1496] Input: Response data sent from the terminal.

[1497] Output: User consent information recorded in a database.

[1498] (Application example 1)

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

[1500] The current way terms of use are presented is difficult for users to understand, and reading the lengthy terms is a hassle. As a result, users may miss important parts of the terms of use or fail to properly confirm their agreement. Furthermore, when the terms of use are changed, users are not notified promptly, making it difficult for them to know whether they have agreed to the latest terms. This increases the likelihood of disputes between service providers and users.

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

[1502] In this invention, the server includes means for converting the terms of use obtained from the service provider into text data, means for analyzing the converted text data and extracting important parts, means for detecting changes to the terms of use and sending a notification to the user terminal, means for selecting particularly important items from the generated summary and creating a checklist, and means for displaying the summary and checklist when the user taps the notification. This allows the important parts of the terms of use to be presented to the user in an easy-to-understand manner, enabling the user to quickly and reliably check important items.

[1503] "Service provider" refers to an institution or organization that provides a service.

[1504] "Terms of Use" refers to a document that stipulates the terms and conditions of use and restrictions of the Service.

[1505] "Means for converting to text data" refers to methods and tools for converting non-text data, such as PDFs and image files, into text format.

[1506] "Means of analyzing and extracting important parts" refers to techniques and methods for analyzing text data using natural language processing technology, etc., and selecting particularly important information from it.

[1507] "Means for generating a summary" refers to techniques or methods for generating concise sentences that are easy for users to understand based on analyzed data.

[1508] "Means for selecting particularly important items and creating a checklist" refers to techniques and methods for selecting items of high importance from the generated summary text and compiling them into a list.

[1509] "Means for transmitting to the user terminal" refers to the communication technology or method for transmitting the generated summary and checklist to the terminal used by the user.

[1510] "Means for detecting changes to the Terms of Use" refers to technologies or methods for automatically detecting changes to the Terms of Use.

[1511] "Means for sending notifications" refers to the technology or method for sending notifications to inform users of changes to the Terms of Use or important matters.

[1512] "Means for displaying the summary and checklist" refers to a technique or method for visually displaying the summary and checklist on a user terminal.

[1513] The present invention is a system that provides users with terms of use obtained from service providers in an easy-to-understand format and confirms their agreement with important items. The main components of this system are a server and a user terminal, and the roles of each are described in detail below.

[1514] Server-side processing

[1515] Obtaining the regulations and converting them into text data

[1516] The server obtains the new terms of use from the service provider. The terms of use are usually provided in PDF format, and to convert them into text data, a library such as PyPDF2 is used.

[1517] Parsing Terms

[1518] The server analyzes the text data using natural language processing (NLP) techniques to identify major sections and extract important keywords, using advanced summarization techniques such as the NLTK library, TF-IDF, and the BERT model.

[1519] Summary generation

[1520] Based on the key parts of the analysis, the server generates a summary in plain language. This summary is generated using a generative AI model (e.g., GPT-3) and provided in a format that is easy for users to understand.

[1521] Creating a summary checklist

[1522] Particularly important points are selected from the generated summary and a checklist is created, which contains important items that the user must agree to.

[1523] Sending data

[1524] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[1525] Detect changes to terms and conditions and send notifications

[1526] The server detects changes to the terms of use and sends push notifications to user devices accordingly, allowing users to quickly access the latest terms of use.

[1527] Terminal side processing

[1528] Receiving and displaying data

[1529] The user device receives the summary and checklist sent from the server and displays them on the screen using HTML, CSS, and JavaScript.

[1530] Collecting user responses

[1531] The user terminal accepts the user's operation of checking each item on the checklist and pressing the "agree" button. Information based on this operation is sent to the server.

[1532] Sending data

[1533] The user device sends the user's response data (checklist and consent history) to the server, which records the user's consent status and helps prevent problems.

[1534] User operations

[1535] Check the terms and conditions

[1536] The user checks the summary of the terms of use displayed on the device. The summary is concise and easy to understand, allowing the user to understand the content in a short amount of time.

[1537] Check the items

[1538] The user checks each item in the checklist, which lists the most important points in the terms of use and displays them in an easy-to-understand format.

[1539] consent

[1540] The user completes the checklist, checks the necessary items, and then presses the "Agree" button. This operation records that the user has agreed to the terms and conditions.

[1541] Specific examples

[1542] For example, when a shopping site publishes new terms of use, users are notified with a prompt like this:

[1543] The new Terms of Use have been published. To review the contents, please open the "Easy Terms of Use Checker" and check the summary and checklist. You must agree to all important items.

[1544] Users can tap the notification to open the app, review the summary and checklist, and agree to the contents to prevent any problems with the service provider.

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

[1546] Step 1:

[1547] The server obtains new terms of use from the service provider. The obtained terms of use are usually in PDF format, and are converted to text data using, for example, the PyPDF2 library. The input is a PDF file, and the output is text data. Converting it to text data makes it easier to analyze later.

[1548] Step 2:

[1549] The server analyzes the converted text data using natural language processing (NLP) techniques. Specifically, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It also summarizes important sections using the BERT model. The input is text data, and the output is important keywords and summaries. This analysis effectively extracts the most important parts of the terms.

[1550] Step 3:

[1551] The server generates a summary in simple language based on the analyzed key parts. The summary is created using a generative AI model (e.g., GPT-3). The input is the analysis result, and the output is a summary that is easy for users to understand. This summary is easy for users to understand, allowing them to grasp the important content in a short amount of time.

[1552] Step 4:

[1553] The server selects particularly important items from the generated summary and creates a checklist. Pre-defined importance criteria are used to create the checklist. The input is the summary, and a checklist containing important items is generated as output. Using this checklist makes it easier for users to check particularly important items.

[1554] Step 5:

[1555] The server sends the generated summary and checklist to the user's terminal. The HTTP / HTTPS protocol is used for transmission. The input is the summary and checklist, and the output is a notification of completion of transmission. By receiving this, the user can confirm important parts of the terms and conditions.

[1556] Step 6:

[1557] The server detects changes to the terms of use and sends a notification to the user's device based on the changes. A change detection algorithm is used to detect changes. The input is the difference information between the old and new terms of use, and the output is a notification message. This notification allows the user to quickly obtain the latest terms of use information.

[1558] Step 7:

[1559] The user checks the summary of the terms of use displayed on the terminal and confirms each item on the checklist. The user checks each item on the checklist and presses the "Agree" button. This input action generates consent confirmation information as output. This consent confirmation information is sent to the server, and the user's consent status is appropriately recorded.

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

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

[1562] The present invention is a system that provides the content of terms of use in a form that is easy for the user to understand, confirms consent to important items, and further combines it with an emotion engine for recognizing the user's emotions. Specific embodiments for carrying out the present invention will be described below.

[1563] 1. Server-side processing

[1564] Obtaining the regulations and converting them into text data

[1565] The server retrieves the new terms of use from the service provider. This is usually a PDF document. The server uses a library (e.g., PyPDF2) to extract the text data from this PDF file.

[1566] Text Preprocessing

[1567] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[1568] Parsing Terms

[1569] The server analyzes the preprocessed text using natural language processing (NLP) techniques.

[1570] The server tokenizes the text and splits it into sentences and phrases.

[1571] The server uses importance evaluation techniques such as TF-IDF to extract important keywords and phrases.

[1572] The server uses the BERT model to generate summaries for each important section.

[1573] Summary generation

[1574] Based on the key parts of the analysis, the server generates a plain-language summary, which is generated according to pre-defined guidelines and templates and presented in a format that is easy for users to understand.

[1575] Creating a summary checklist

[1576] The server selects the most important points from the generated summary and creates a checklist containing important items that the user must agree to.

[1577] For example, generate an item in the form "■ You must be 18 years of age or older to use this service."

[1578] Sending data

[1579] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[1580] 2. Terminal processing

[1581] Receiving and displaying data

[1582] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[1583] Emotion recognition with emotion engine

[1584] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time to understand how the user is reacting to the information displayed.

[1585] Collecting user responses

[1586] The device accepts the user's operation of checking each check box and pressing the "Agree" button. Depending on the user's emotional state, it is possible to further simplify the explanation or provide supplementary information.

[1587] Sending data

[1588] The device sends the user's responses (checklist status and consent information) and emotion data to the server using the HTTP / HTTPS protocol.

[1589] 3. User Operation

[1590] Check the terms and conditions

[1591] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[1592] Check the items

[1593] The user checks each item in the checklist, which lists particularly important matters in the terms of use.

[1594] consent

[1595] The user completes the checklist and checks the necessary items. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[1596] Specific examples

[1597] Server-side processing example

[1598] The server retrieves "Service A Terms of Use.pdf" and converts it into text data using the PyPDF2 library. Next, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It then uses the BERT model to generate a summary of the important sections and summarize them in plain text. It selects important points and creates a checklist. Finally, it sends the summary and checklist to the user's device.

[1599] Example of terminal processing

[1600] The device receives the summary and checklist sent from the server and displays them on the screen. It uses an emotion engine to analyze the user's facial expressions and voice and provides feedback according to the user's emotional state. When the user checks the checkboxes and presses the consent button, the collected response data and emotional data are sent to the server.

[1601] User operation example

[1602] The user checks the summary displayed on the device and ticks the important points. After checking all the check items, taking into consideration the feedback analyzed by the emotion engine, the user presses the "Agree" button. This indicates consent to the terms and conditions, and this consent is recorded.

[1603] The processing flow will be explained below.

[1604] Server Processing

[1605] Step 1: Obtaining the terms and converting them to text data

[1606] The server retrieves the new terms of use from the service provider. This is usually a PDF document. The server uses a library (e.g., PyPDF2) to extract the text data from this PDF file.

[1607] Step 2: Preprocessing the text

[1608] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[1609] Step 3: Parsing the Terms

[1610] The server analyzes the preprocessed text using natural language processing (NLP) techniques. Specifically, it performs the following operations:

[1611] The server tokenizes the text and splits it into sentences and phrases.

[1612] The server uses importance evaluation techniques such as TF-IDF to extract important keywords and phrases.

[1613] The server uses the BERT model to generate summaries for each important section.

[1614] Step 4: Generate a summary

[1615] The server generates a summary in plain language based on the key parts of the analysis, using pre-defined templates and guidelines to avoid technical jargon and difficult expressions and make the summary easy for users to understand.

[1616] Step 5: Create a summary checklist

[1617] The server selects particularly important points from the generated summary and creates a checklist. The checklist contains important items that the user must agree to. For example, it generates items in a specific format such as "■ You must be 18 years of age or older to use this service."

[1618] Step 6: Send the data

[1619] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[1620] Terminal handling

[1621] Step 1: Receiving and displaying data

[1622] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[1623] Step 2: Emotion recognition by the emotion engine

[1624] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time to understand how the user is reacting to the information displayed.

[1625] Step 3: Provide feedback

[1626] The device provides appropriate feedback to the user based on the analysis results obtained from the emotion engine. If the user's level of understanding is low, the device may display a more concise explanation or provide additional information.

[1627] Step 4: Collect user responses

[1628] The terminal accepts the user's operation to check each check item, and after the user has confirmed all items, accepts the user's press of the consent button.

[1629] Step 5: Send the data

[1630] The device sends the user's responses (checklist status and consent information) and emotion data to the server using the HTTP / HTTPS protocol.

[1631] User operations

[1632] Step 1: Review the terms and conditions

[1633] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[1634] Step 2: Check the items

[1635] The user checks each item on the checklist, which lists the most important points in the terms of use.

[1636] Step 3: Accept

[1637] The user checks the checklist and checks each item. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[1638] Example 2

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

[1640] In today's world, with many services being provided online, terms of use are important, legally binding documents. However, these documents are often lengthy and full of technical terms, which creates a problem: many users agree to the terms without fully understanding them. It is also difficult to verify whether users actually agree to the terms. Furthermore, understanding the emotional state of users when they agree is crucial, but current systems are unable to address this issue.

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

[1642] In this invention, the server includes: means for converting terms of use obtained from a service provider into text data; means for normalizing unnecessary spaces, line breaks, and special characters from the converted text data; means for analyzing the converted and normalized text data and extracting important parts; means for generating a summary of the extracted important parts in plain language; means for selecting particularly important matters from the generated summary and creating a checklist; means for transmitting the generated summary and checklist to a user terminal; and means including an emotion engine for analyzing the user's emotional state. This allows the user to easily understand the contents of the terms of use and reliably obtain consent to important matters. Furthermore, analyzing the user's emotional state enables further feedback and adaptive responses.

[1643] "Service Provider" refers to a legal entity or individual that provides a particular service to a User.

[1644] "Terms of Use" refers to a document that describes the terms and rules of use for the services provided by a service provider.

[1645] "Means for converting to text data" refers to technology or methods for converting document formats such as PDF into text format.

[1646] "Normalization" refers to the process of systematically organizing and removing unnecessary spaces, line breaks, and special characters to maintain data consistency.

[1647] "Analysis" refers to the process of analyzing text data using natural language processing and other techniques to extract meaning and important information.

[1648] "Tokenization" refers to the process of breaking text into smaller units such as words, sentences, or phrases.

[1649] "Important parts" refers to sections or keywords in the Terms of Use that are deemed to be particularly important to users.

[1650] A "summary" is a short document that extracts important information from the original text and summarizes it in simple language.

[1651] A "checklist" is a document that lists important items and things that need to be checked.

[1652] "User terminal" refers to a device such as a smartphone, tablet, or PC that a user uses to access the service.

[1653] An "emotion engine" is a technology that analyzes a user's facial expressions and voice, and refers to a system for estimating the user's emotional state.

[1654] This invention is a system that provides users with terms of use in an easy-to-understand format, confirms their agreement to important items, and combines an emotion engine to recognize the user's emotions. This system operates in cooperation with the server, terminal, and user elements.

[1655] Server-side processing

[1656] The server first obtains the new terms of use from the service provider. This is usually a PDF document. The server uses software to convert the document to text data, such as the PyPDF2 library. The server uses this library to extract the text data from the PDF file.

[1657] The extracted text data is difficult to analyze as is, so unnecessary spaces, line breaks, and special characters are normalized. This is done using regular expression processing, etc. The server then analyzes the normalized text data using natural language processing (NLP) techniques. For example, this analysis involves tokenizing the text using the NLTK library and extracting important keywords using TF-IDF techniques.

[1658] The server then uses a generative AI model, such as the BERT model, to generate a summary of each important section. This summary is then written in plain language, making it easy for users to understand. The server then selects the most important points from the summary and creates a checklist, which includes key items that users should agree to.

[1659] Finally, the server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[1660] Terminal side processing

[1661] The device receives the summary and checklist sent from the server and displays them in a user-friendly format. This display uses HTML, CSS, and JavaScript. Furthermore, the device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time. This emotion engine, which uses OpenCV and TensorFlow, for example, to understand how the user is reacting to the displayed information.

[1662] The device also accepts the user's operation of checking checklist items and pressing the "Agree" button. Depending on the user's emotional state, the device can further simplify the explanation or provide additional supplementary information. The device then transmits the collected response data and emotional data to the server.

[1663] User operations

[1664] The user checks the summary of the terms of use displayed on the device. The summary is written in simple language so that the content can be understood in a short time. Next, the user checks each item on the checklist and checks the necessary items. After checking all the items, the user presses the "Agree" button to agree to the terms of use. This records the user's agreement.

[1665] Specific examples

[1666] The server retrieves "Service A Terms of Use.pdf" and converts it into text data using the PyPDF2 library. Next, it tokenizes the text using the NLTK library and extracts important keywords using TF-IDF. It then uses the BERT model to generate a summary of the important sections and summarize them in plain text. It selects important points and creates a checklist. Finally, it sends the summary and checklist to the user's device.

[1667] The device receives the summary and checklist sent from the server and displays them on the screen. It uses an emotion engine (e.g., OpenCV or TensorFlow) to analyze the user's facial expressions and voice and provide feedback according to the user's emotional state. When the user checks the checkboxes and presses the consent button, the collected response data and emotional data are sent to the server.

[1668] The user checks the summary displayed on the device and ticks the important points. After checking all the check items, taking into consideration the feedback analyzed by the emotion engine, the user presses the "Agree" button. This indicates consent to the terms and conditions, and this consent is recorded.

[1669] Prompt Sentence Examples

[1670] "What library will the server use to extract text data from PDF files? And what technique will it use to extract important keywords?"

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

[1672] Step 1:

[1673] The server obtains a PDF file of the terms of use (e.g., "ServiceATermsOfUse.pdf") from the service provider. The obtained PDF file is saved in a specific directory on the server. The input for this step is "ServiceATermsOfUse.pdf", and the output is the PDF file saved in the specified directory on the server.

[1674] Step 2:

[1675] The server uses the PyPDF2 library to extract text data from PDF files. It receives a PDF file as input and obtains text data as output. Specifically, it opens the PDF file and extracts text from each page sequentially. This process converts the contents of "Service A Terms of Use.pdf" into pure text data.

[1676] Step 3:

[1677] The server normalizes the extracted text data to remove unnecessary whitespace, line breaks, and special characters. The input is the extracted raw text data, and the output is the normalized, clean text data. Specifically, it uses regular expressions to remove unnecessary whitespace and line breaks and format the text into a consistent format.

[1678] Step 4:

[1679] The server analyzes the normalized text data using natural language processing (NLP) techniques. First, it tokenizes the text using the NLTK library. The input is normalized text data, and the output is tokenized text. Specifically, it splits the text into words, sentences, and phrases.

[1680] Step 5:

[1681] The server extracts important keywords and phrases using TF-IDF technology. The input is tokenized text data, and the output is a list of important keywords and phrases. Specifically, it calculates the frequency of occurrence of each word or phrase and evaluates its importance.

[1682] Step 6:

[1683] The server uses a generative AI model, such as the BERT model, to generate summaries for each key section. The input is text data containing important keywords and phrases, and the output is a summary. Specifically, the server analyzes the text using a pre-trained BERT model and generates a summary.

[1684] Step 7:

[1685] The server selects particularly important items from the generated summary and creates a checklist. The input is the summary, and the output is the checklist. Specifically, the server evaluates the summary and extracts important items that the user should check.

[1686] Step 8:

[1687] The server sends the generated summary and checklist to the user terminal. The input is the summary and checklist, and the output is transmission to the user terminal. Specifically, the data is sent using the HTTP / HTTPS protocol.

[1688] Step 9:

[1689] The terminal receives the summary and checklist sent from the server. The input is the data sent from the server, and the output is the display of the received summary and checklist. Specific operations use HTML, CSS, and JavaScript to display the received data on the screen.

[1690] Step 10:

[1691] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time. The input is the user's facial expressions and voice, and the output is emotional data as the analysis result. Specifically, it collects user data via a camera and microphone and uses analysis software to estimate the user's emotional state.

[1692] Step 11:

[1693] The terminal accepts the user's operation of checking each item on the checklist and pressing the consent button. The input is the user's operation, and the output is the checklist status and consent information. Specifically, the terminal accepts user input through a user interface.

[1694] Step 12:

[1695] The terminal sends the collected response data and emotion data to the server. The input is the user's response data and emotion data, and the output is transmission to the server. Specifically, the data is sent using the HTTP / HTTPS protocol.

[1696] Step 13:

[1697] The user checks the summary displayed on the terminal and checks the important items. The input is the summary and the checklist, and the output is the checked checklist. Specifically, the user reads each item and checks the necessary items.

[1698] Step 14:

[1699] After the user has checked all the check items, they press the Agree button. The input is the checked checklist, and the output is an expression of consent. Specifically, the user indicates consent by pressing the Agree button based on the items they have checked.

[1700] (Application example 2)

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

[1702] Conventional terms of service confirmation systems present users with lengthy, difficult-to-understand terms and conditions, making it difficult for them to efficiently review important parts and resulting in a poor user experience. Furthermore, in autonomous vehicles, if consent to the terms and conditions is not obtained quickly and reliably, it could affect safety and service quality. Furthermore, providing information uniformly without considering the user's emotional state can also cause problems, with some users being unable to accurately understand the content.

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

[1704] In this invention, the server includes means for converting the terms of use acquired from the service provider into text data, means for analyzing the converted text data and extracting important parts, means for generating a summary of the extracted important parts in plain language, means for selecting particularly important matters from the generated summary and creating a checklist, means for transmitting the generated summary and checklist to a user terminal, emotion recognition means for analyzing the user's emotions in real time in the user terminal to obtain user consent for the autonomously driving vehicle, and means for providing additional explanations according to the user's emotional state. This enables the user to confirm important matters of the terms of use in an easy-to-understand format, obtain consent quickly and reliably, and further enables flexible provision of information according to the user's emotional state.

[1705] "Service Provider" refers to a company or organization that offers a particular service or product.

[1706] "Terms of Use" refers to a document that lists the rules and conditions that users must follow when using a service.

[1707] "Text data" refers to information stored as character string data.

[1708] "Means for converting" refers to a method or device for converting data of one format into another format.

[1709] "Means for analysis" refers to methods and devices for analyzing data and understanding its contents.

[1710] "Important parts" refers to information or content that is particularly important within the whole.

[1711] "Plain writing" refers to writing that is easy to understand and simply written.

[1712] A "summary" is a sentence that summarizes a longer piece of text in a short form.

[1713] A "checklist" is a list of items to be checked.

[1714] "User terminal" refers to a device used by a user, including a personal computer or smartphone.

[1715] "Emotion recognition means" refers to a method or device for analyzing and understanding a user's emotions.

[1716] "Additional explanation" refers to an explanation added to supplement the original explanation.

[1717] "Agreement button" refers to a button that allows a user to indicate their consent to certain matters.

[1718] "Natural language processing technology" refers to the technology that uses computers to process and understand human language.

[1719] This invention is a system that optimizes the process for users of autonomous vehicles to confirm terms of use in an easy-to-understand manner and agree to important matters. This system consists of a server side and a terminal side, and the functions and processing methods of each are explained below.

[1720] Server-side processing

[1721] Obtaining rules and converting them to text data

[1722] The server retrieves the new terms of service from the service provider, usually as a PDF document, and uses the PyPDF2 library to extract the text data from the PDF file.

[1723] Text Preprocessing

[1724] The server preprocesses the extracted text data, which includes removing line breaks and unnecessary whitespace, and normalizing special characters, making it easier to parse.

[1725] Parsing Terms

[1726] The server analyzes the preprocessed text using natural language processing (NLP) techniques, tokenizing the text and extracting important keywords and phrases using importance evaluation techniques such as TF-IDF, and then generates summaries for each important section using the BERT model.

[1727] Summary and checklist generation

[1728] Based on the analyzed important parts, the server generates a summary in plain language. This summary is generated according to pre-defined guidelines and templates and is provided in a format that is easy for users to understand. Particularly important points are selected from the generated summary to create a checklist.

[1729] Sending data

[1730] The server sends the generated summary and checklist to the user's terminal using the HTTP / HTTPS protocol.

[1731] Terminal side processing

[1732] Receiving and displaying data

[1733] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format using HTML, CSS, and JavaScript.

[1734] Emotion recognition with emotion engine

[1735] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time to understand how the user is reacting to the information displayed.

[1736] Collecting user responses

[1737] The device accepts the user's operation of checking each check box and pressing the "Agree" button. It is also possible to further simplify the explanation or provide supplementary information depending on the user's emotional state.

[1738] Sending data

[1739] The device sends the user's responses (checklist status and consent information) and emotion data to the server using the HTTP / HTTPS protocol.

[1740] User operations

[1741] Check the terms and conditions

[1742] The user checks the summary of the terms of use displayed on the device. The summary is written concisely and easily understandable, allowing the user to grasp the contents in a short time.

[1743] Check the items

[1744] The user checks each item in the checklist, which lists particularly important matters in the terms of use.

[1745] consent

[1746] The user completes the checklist and checks the necessary items. After reading through all the check items, the user presses the "Agree" button. This records that the user has agreed to the terms and conditions.

[1747] Specific examples and prompts for the generative AI model

[1748] As a concrete example, consider the procedure for getting into a self-driving car. Since many users find it tedious to read the service's terms of use all at once, the system presents important information succinctly and analyzes the user's emotional state to provide feedback, facilitating the consent process.

[1749] Example prompt sentence:

[1750] Your goal is to create a Python program that converts PDF-formatted terms of use into an easy-to-understand summary for users, and then obtains their consent to key terms. On the server side, you will use the PyPDF2 library to extract text and create a summary using the BERT model. On the device side, you will analyze user sentiment and manage the consent process.

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

[1752] Step 1:

[1753] The server receives the new terms of use in PDF format from the service provider. The input is a PDF document, which is saved on the server. The output is the PDF file itself.

[1754] Step 2:

[1755] The server extracts text data from a PDF file using the PyPDF2 library by opening the PDF file and getting the text from each page sequentially. The input is the PDF file, and the output is the extracted text data.

[1756] Step 3:

[1757] The server preprocesses the extracted text data. In this process, unnecessary line breaks, spaces, and special characters are removed from the text. The input is the extracted text data, and the output is the preprocessed, clean text data.

[1758] Step 4:

[1759] The server analyzes the preprocessed text data using natural language processing (NLP) techniques. This involves tokenizing the text and extracting important keywords and phrases using TF-IDF. It then generates summaries for each important section using the BERT model. The input is the preprocessed text data, and the output is important keywords and summary sentences.

[1760] Step 5:

[1761] The server generates a plain-language summary based on the key parts of the analysis. The summary is created according to pre-defined guidelines and templates. The input is key keywords and a draft summary, and the output is the final summary in a format that is easy for the user to understand.

[1762] Step 6:

[1763] The server selects particularly important items from the generated summary and creates a checklist. The input is the summary, and the output is a checklist that lists the particularly important items.

[1764] Step 7:

[1765] The server sends the generated summary and checklist to the user terminal via HTTP / HTTPS protocol. The input is the summary and checklist, and the output is the data sent to the user terminal.

[1766] Step 8:

[1767] The terminal receives the summary and checklist sent from the server, parses them, and displays them in a user-friendly format. HTML, CSS, and JavaScript are used for display. The input is the summary and checklist sent from the server, and the output is the content displayed on the user's screen.

[1768] Step 9:

[1769] The device uses a built-in emotion engine to analyze the user's facial expressions and voice in real time. The emotion engine analyzes how the user reacts to displayed information and grasps their emotional state. The input is the user's facial expressions and voice, and the output is analyzed emotional state data.

[1770] Step 10:

[1771] The device further simplifies the explanation or provides supplementary information according to the user's emotional state. The input is emotional state data, and the output is an explanation optimized according to the user's level of understanding and emotions.

[1772] Step 11:

[1773] The terminal accepts the user's operation of checking each check item and pressing the consent button. Based on the user's operation, the terminal collects the checklist status and consent information. The input is the user's operation, and the output is the collected user response data.

[1774] Step 12:

[1775] The terminal sends the collected response data and emotion data to the server using the HTTP / HTTPS protocol. The input is the user's response data and emotion data, and the output is the data sent to the server.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[1797] The following is further disclosed regarding the above embodiment.

[1798] (Claim 1)

[1799] A means for converting the terms of use obtained from the service provider into text data;

[1800] A means for analyzing the converted text data and extracting important parts;

[1801] A means for generating a summary of the extracted important parts in simple language;

[1802] A means for selecting particularly important matters from the generated summary sentences and creating a checklist;

[1803] means for transmitting the generated summary and checklist to a user terminal;

[1804] A system including:

[1805] (Claim 2)

[1806] 2. The system according to claim 1, wherein the user checks each item on the checklist on the terminal and presses an "agree" button, thereby collecting the user's response and transmitting the response to the server.

[1807] (Claim 3)

[1808] 2. The system according to claim 1, wherein the system uses natural language processing technology to analyze the text data of the terms of use and extract important keywords.

[1809] "Example 1"

[1810] (Claim 1)

[1811] A means for converting the terms of use obtained from the service provider into text data;

[1812] means for analyzing the converted text data, identifying important sections, and extracting important keywords;

[1813] A means for generating a summary of the extracted important parts in simple language;

[1814] A means for selecting particularly important matters from the generated summary sentences and creating a checklist;

[1815] means for transmitting the generated summary and checklist to a user terminal;

[1816] A system including:

[1817] (Claim 2)

[1818] 2. The system according to claim 1, wherein the user checks each item on the checklist on the terminal and presses an "agree" button, thereby collecting the user's response and transmitting the response to the server.

[1819] (Claim 3)

[1820] The system of claim 1, further comprising: means for analyzing the text data of the terms of use using natural language processing technology, identifying major sections, and extracting important keywords; and means for summarizing the text data into plain text using a summarization model.

[1821] "Application Example 1"

[1822] (Claim 1)

[1823] A means for converting the terms of use obtained from the service provider into text data;

[1824] A means for analyzing the converted text data and extracting important parts;

[1825] A means for generating a summary of the extracted important parts in simple language;

[1826] A means for selecting particularly important matters from the generated summary sentences and creating a checklist;

[1827] means for transmitting the generated summary and checklist to a user terminal;

[1828] A means for detecting changes to the terms of use and sending a notification to the user's device;

[1829] A means for displaying a summary and a checklist by a user tapping the notification;

[1830] A system including:

[1831] (Claim 2)

[1832] 2. The system according to claim 1, wherein the user checks each item on the checklist on the terminal and presses an "agree" button, thereby collecting the user's response and transmitting the response to the server.

[1833] (Claim 3)

[1834] 2. The system according to claim 1, wherein the system uses natural language processing technology to analyze the text data of the terms of use and extract important keywords.

[1835] "Example 2: Combining Emotion Engines"

[1836] (Claim 1)

[1837] A means for converting the terms of use obtained from the service provider into text data;

[1838] A means to normalize unnecessary spaces, line breaks, and special characters from the converted text data,

[1839] a means for analyzing the transformed and normalized text data and extracting significant portions;

[1840] A means for generating a summary of the extracted important parts in simple language;

[1841] A means for selecting particularly important matters from the generated summary sentences and creating a checklist;

[1842] means for transmitting the generated summary and checklist to a user terminal;

[1843] means including an emotion engine for analyzing an emotional state of a user;

[1844] A system including:

[1845] (Claim 2)

[1846] 2. The system according to claim 1, wherein the user checks each item on the checklist on the terminal and presses an "agree" button, thereby collecting the user's response and transmitting the response to the server.

[1847] (Claim 3)

[1848] 2. The system according to claim 1, wherein the system uses natural language processing technology to analyze the text data of the terms of use and extract important keywords.

[1849] "Application example 2 when combining emotion engines"

[1850] (Claim 1)

[1851] A means for converting the terms of use obtained from the service provider into text data;

[1852] A means for analyzing the converted text data and extracting important parts;

[1853] A means for generating a summary of the extracted important parts in simple language;

[1854] A means for selecting particularly important matters from the generated summary sentences and creating a checklist;

[1855] means for transmitting the generated summary and checklist to a user terminal;

[1856] An emotion recognition means for analyzing a user's emotion in real time in a user terminal in order to obtain user consent for an autonomous driving vehicle;

[1857] means for providing additional explanations depending on the user's emotional state;

[1858] A system including:

[1859] (Claim 2)

[1860] 2. The system according to claim 1, wherein the user checks each item on the checklist on the terminal and presses an "agree" button, thereby collecting the user's response and transmitting the response to the server.

[1861] (Claim 3)

[1862] 2. The system according to claim 1, wherein the system uses natural language processing technology to analyze the text data of the terms of use and extract important keywords. [Explanation of symbols]

[1863] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. A means for converting the terms of use obtained from the service provider into text data; A means for analyzing the converted text data and extracting important parts; A means for generating a summary of the extracted important parts in simple language; A means for selecting particularly important matters from the generated summary sentences and creating a checklist; means for transmitting the generated summary and checklist to a user terminal; A system including:

2. 2. The system according to claim 1, wherein the user checks each item on the checklist on the terminal and presses an "agree" button, thereby collecting the user's response and transmitting the response to the server.

3. The system according to claim 1, wherein the system analyzes the text data of the terms of use using natural language processing technology to extract important keywords.

Images