system

Abstract

Provide a system. 【Solution means】 Means for uploading a contract file, Means for analyzing the structure and content of a contract using an AI model, Means for extracting missing keywords based on the analysis results, Means for generating an amendment for modifying the provisions in the contract, Means for confirming and applying the amendment presented to the user, Means for identifying and notifying special provisions in the contract, Means for generating a new provision based on the user's request and inserting it into the contract, A system including means for saving and providing the generated final version of the contract.

Description

Technical Field

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

Background Art

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

Prior Art Documents

Patent Documents

[0003]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0004] The confirmation and correction work of contracts requires a lot of time and expertise. Especially in the business field, a quick and accurate response is required. However, in the conventional manual checking and correction work, there are problems such as being prone to overlooking and making mistakes, and it is difficult to find specific clauses and missing keywords. Furthermore, it is difficult to detect special clauses, increasing the burden on legal staff. There is a need for a system that solves these problems and efficiently and accurately checks and corrects contracts.

Means for Solving the Problems

[0005] The present invention solves the above problems with a system that includes means for uploading a contract file, means for analyzing the structure and content of the contract using an AI model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for confirming and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating new clauses based on user requests and inserting them into the contract, and means for saving and providing the generated final version of the contract. This enables quick and accurate confirmation and revision of contracts, reduces the burden on legal personnel, and improves efficiency in business settings.

[0006] A "contract file" is an electronic file containing the contents of a contract, and its format includes PDF, Word, and text files.

[0007] "Means of uploading" refers to a function that allows a user to transfer contract files from their device to a server, and includes file transfer technologies via the internet.

[0008] An "AI model" is a program or algorithm that uses artificial intelligence to analyze data, and has the function of analyzing the contents of a contract based on a pre-trained dataset.

[0009] The "means of analysis" refer to the function of inputting the contents of a contract file into an AI model and executing a process to understand and classify its structure and content.

[0010] The "keyword extraction method" is a function that detects specific keywords based on certain criteria from the analysis results of a contract and lists any missing keywords.

[0011] The "means for generating revised proposals" refer to a function that, when there are deficiencies in the clauses or content of a contract, creates appropriate revised proposals by referring to standard clause templates or existing data.

[0012] "Means of review and application" refers to a function that provides an interface and operations for users to review proposed revisions and apply them to the contract.

[0013] "Means for identifying and notifying special clauses" refers to a function that discovers unusual or abnormal clauses within a contract and informs the user of them.

[0014] "Means for generating and inserting new clauses into a contract" refers to a function that generates new contract clauses in response to user requests and adds them to the appropriate location in the contract.

[0015] "Means of saving and providing the final version of the contract" refers to a function that saves the final version of the contract after any revisions or additions have been completed and provides a download link as needed. [Brief explanation of the drawing]

[0016] [Figure 1] This is a conceptual diagram showing an example of the configuration of a data processing system according to the first embodiment. [Figure 2] This is a conceptual diagram showing an example of the essential functions of a data processing device and a smart device according to the first embodiment. [Figure 3] This is a conceptual diagram showing an example of the configuration of a data processing system according to the second embodiment. [Figure 4] This is a conceptual diagram showing an example of the main functions of a data processing device and smart glasses according to the second embodiment. [Figure 5] This is a conceptual diagram showing an example of the configuration of a data processing system according to the third embodiment. [Figure 6] This is a conceptual diagram showing an example of the main functions of a data processing device and a headset-type terminal according to the third embodiment. [Figure 7] This is a conceptual diagram showing an example of the configuration of a data processing system according to the fourth embodiment. [Figure 8] This is a conceptual diagram showing an example of the main functions of a data processing device and a robot according to the fourth embodiment. [Figure 9] Shows an emotion map to which a plurality of emotions are mapped. [Figure 10] Shows an emotion map to which a plurality of emotions are mapped. [Figure 11] It is a sequence diagram showing the processing flow of the data processing system in Embodiment 1. [Figure 12] It is a sequence diagram showing the processing flow of the data processing system in Application Example 1. [Figure 13] It is a sequence diagram showing the processing flow of the data processing system in Embodiment 2 when an emotion engine is combined. [Figure 14] It is a sequence diagram showing the processing flow of the data processing system in Application Example 2 when an emotion engine is combined.

Mode for Carrying Out the Invention

[0017] Hereinafter, an example of an embodiment of a system according to the technology of the present disclosure will be described with reference to the accompanying drawings.

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

[0019] In the following embodiments, a processor with a reference numeral (hereinafter simply referred to as "processor") may be a single arithmetic unit or a combination of a plurality of arithmetic units. Also, the processor may be a single type of arithmetic unit or a combination of a plurality of types of arithmetic units. Examples of arithmetic units include a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-Purpose computing on Graphics Processing Units), an APU (Accelerated Processing Unit), and the like.

[0020] In the following embodiments, signed RAM (Random Access Memory) is a memory that temporarily stores information and is used as work memory by the processor.

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

[0022] In the following embodiments, the signed communication interface (I / F) is an interface that includes a communication processor and an antenna, etc. The communication interface manages communication between multiple computers. Examples of communication standards applicable to the communication interface include wireless communication standards such as 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), or Bluetooth (registered trademark).

[0023] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." That is, "A and / or B" means that it may be A alone, or B alone, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" applies when expressing three or more things linked by "and / or."

[0024] [First Embodiment]

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

[0026] As shown in Figure 1, the data processing system 10 includes a data processing device 12 and a smart device 14. An example of the data processing device 12 is a server.

[0027] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0029] The reception device 38 is equipped with a touch panel 38A and a microphone 38B, etc., and receives user input. The touch panel 38A receives user input by detecting contact with an object (e.g., a pen or finger). The microphone 38B receives user input by detecting the user's voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the data indicating the user input.

[0030] The output device 40 includes a display 40A and a speaker 40B, and presents data to the user 20 by outputting the data in a form perceptible to the user 20 (e.g., audio and / or text). The display 40A displays visible information such as text and images according to instructions from the processor 46. The speaker 40B outputs audio according to instructions from the processor 46. The camera 42 is a small digital camera equipped with an optical system such as a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0031] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various types of information between processor 46 and processor 28 via network 54.

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

[0033] As shown in Figure 2, in the data processing device 12, a specific processing 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" related to the technology of this 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 according to the specific processing program 56 executed on the RAM 30.

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

[0035] In the smart device 14, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The reception output program 60 is used in conjunction with a 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 processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

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

[0037] ---

[0038] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, performs AI-based analysis, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract. Specific embodiments of this system are described below.

[0039] Virtual system configuration

[0040] User terminal

[0041] It provides an interface that allows users to upload contract files, review and apply proposed revisions, and add new clauses.

[0042] server

[0043] The system receives and saves contract files, performs AI analysis, extracts missing keywords, generates proposed revisions, identifies special clauses, and generates and saves the final version of the contract.

[0044] Program processing and specific examples

[0045] 1. Upload the contract.

[0046] The user terminal has the functionality to upload contract files to the server by the user selecting a contract file and clicking a button.

[0047] Example: The user selects "Draft Contract.pdf" from their device and clicks the upload button.

[0048] 2. Analysis of the contract

[0049] The server receives and saves the uploaded contract file. The saved file is converted into text data and input into the AI ​​model. The AI ​​model analyzes the structure and content of the contract and classifies each clause.

[0050] Example: The server converts "Draft Contract.pdf" into text data and categorizes it as "Clause 1: Delivery Date" and "Clause 2: Payment Terms".

[0051] 3. Extraction of missing keywords

[0052] Based on the analysis results, the server compares them against a list of keywords required for a standard contract and detects any missing keywords. This information is then notified to the user.

[0053] Example: It was discovered that the contract lacked a "disclaimer clause," and the user was notified with the message, "The disclaimer clause is missing."

[0054] 4. Generating draft amendments to the articles

[0055] The server analyzes the contract to identify any missing sections or clauses that need revision, and generates a draft revision. The generated draft revision is then presented to the user.

[0056] Example: Present the user with a proposed revision, such as "In no event shall we be liable for any indirect or consequential damages," as an example of a disclaimer.

[0057] 5. User verification

[0058] The user terminal provides an interface that allows the user to review the proposed corrections and choose whether or not to apply them.

[0059] Example: The user reviews the proposed revisions to the "Disclaimer" and clicks the Apply button.

[0060] 6. Extraction and notification of special provisions

[0061] The server detects unusual content or abnormal clauses within the contract and displays a warning to the user.

[0062] Example: A clause containing high penalties for delayed delivery was detected and notified to the user. The system warned that "this clause is not included in typical contracts."

[0063] 7. Creation and insertion of new articles

[0064] The user terminal provides the functionality to add new clauses based on user requests. The server inserts the generated clauses into the contract.

[0065] For example, if a user enters a request to "add a new data protection clause," the server will generate the following data protection clause: "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy," and insert it into the agreement.

[0066] 8. Generation and delivery of the final version

[0067] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[0068] Example: After the user has finished reviewing the final revisions, the server generates the final version of the contract. The user can then download the final version by clicking the download link.

[0069] In this way, the system of the present invention can efficiently and accurately perform the review, modification, and addition of new clauses to contracts.

[0070] The following describes the processing flow.

[0071] Step 1:

[0072] The user selects the contract file from their device's browser and clicks the "Upload" button.

[0073] Specific operation: The user selects a contract file (e.g., PDF or Word file) through a file selection dialog and clicks the upload button in the browser.

[0074] Step 2:

[0075] The terminal sends the selected file to the server.

[0076] Specific operation: The device sends an HTTP request to the server via the internet and attaches the selected contract file.

[0077] Step 3:

[0078] The server receives the contract file, saves it to storage, detects the file format, and then converts it to text format.

[0079] Specific operation: The server saves the file to a specific directory and converts it into text data using OCR (Optical Character Recognition) or other file conversion tools.

[0080] Step 4:

[0081] The server inputs the converted text data into an AI model, which analyzes the structure of the contract and each clause.

[0082] Specific operation: The server supplies text data to the AI ​​model, and the model identifies and classifies each section and clause in the contract.

[0083] Step 5:

[0084] The server compares the analysis results against a list of keywords required for a standard contract and extracts any missing keywords.

[0085] Specific operation: The server compares the contract text with the keyword list and lists any missing keywords.

[0086] Step 6:

[0087] The server notifies the user of a list of missing keywords.

[0088] Specific operation: The server generates a web page to display incomplete keywords on the user interface and presents it to the user.

[0089] Step 7:

[0090] The server automatically generates proposed revisions for any missing or necessary clauses in the contract.

[0091] Specific operation: The server uses a natural language generation (NLG) algorithm to create proposed amendments while referring to standard clause templates.

[0092] Step 8:

[0093] The server presents the generated proposed fixes to the user.

[0094] Specific operation: The server displays a list of proposed fixes as a web page, allowing users to view it.

[0095] Step 9:

[0096] The user reviews the proposed changes and chooses whether to apply them.

[0097] Specific action: The user reviews the proposed changes and accepts them by clicking the apply button.

[0098] Step 10:

[0099] The server identifies any special clauses included in the contract and notifies the user.

[0100] Specific operation: The server uses an AI model to detect abnormal clauses and displays a warning message to the user.

[0101] Step 11:

[0102] The user requests the addition of a new clause.

[0103] Specific action: The user uses a browser input form to enter the content and type of the new clause.

[0104] Step 12:

[0105] The server generates new clauses based on the user's request and inserts them into the contract.

[0106] Specific operation: The server generates a new clause and inserts its content into the appropriate location.

[0107] Step 13:

[0108] The server generates and saves the final version of the contract after all modifications and additions have been completed.

[0109] Specific operation: The server saves the final text data and generates the final version of the contract file.

[0110] Step 14:

[0111] The user reviews and downloads the final version of the contract.

[0112] Specific action: The user clicks the download link for the final version of the contract and saves the file to their device.

[0113] This process allows for efficient and accurate review, revision, detection of special clauses, and addition of new clauses to contracts.

[0114] (Example 1)

[0115] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0116] Traditional contract review and revision processes are often manual, making them time-consuming, laborious, and prone to human error. Furthermore, it was difficult to quickly and accurately address non-standard contracts or those requiring minor revisions. Advanced tasks such as generating new clauses and detecting and notifying users of special clauses were also extremely cumbersome when performed manually. There is a need for a system that can solve these problems and efficiently and accurately perform contract review, revision, addition of new clauses, and generation of final versions.

[0117] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0118] In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using a generative AI model, means for converting the contract file into text data using a text processing library, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for reviewing and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating and inserting new clauses based on user requests into the contract, means for saving and providing the generated final version of the contract, and means for generating prompt sentences used for analyzing the contract from a training dataset. This makes it possible to efficiently and accurately review, revise, add new clauses, and detect and notify special clauses in contracts.

[0119] A "contract file" is a document containing the details of a contract, stored in an electronic format.

[0120] "Method of uploading" refers to the function that allows users to send contract files from their own devices to the server.

[0121] A "generative AI model" is an artificial intelligence system that has been trained in advance using various datasets, and is used to analyze the structure and content of contracts.

[0122] "Means of analysis" refers to a function that automatically analyzes the content and structure of contract files and extracts necessary information.

[0123] A "text processing library" is a software component used to convert electronic documents into text data.

[0124] "Text data" refers to data that represents the content of a document as a string of characters.

[0125] "Missing keywords" are important words or phrases that should be included in a standard contract but are not present in the contract being analyzed.

[0126] "Means for generating revised proposals" refers to a function that automatically creates specific suggestions for revisions or additions to clauses within a contract when necessary.

[0127] A "user terminal" refers to a device used by a user to perform operations such as uploading contracts, reviewing and applying proposed revisions, and adding new clauses.

[0128] A "special clause" refers to a clause that contains specific conditions or provisions not typically found in standard contracts.

[0129] A "new clause" refers to a clause that is newly added to the contract based on the user's request.

[0130] The "final version of the contract" refers to the final contract file after all revisions and additions have been completed.

[0131] "Means of saving and providing" refers to the function of saving the final generated version of the contract on a server and making it available for users to download.

[0132] A "prompt statement" refers to a question or command input to an AI model, and is a document used for analyzing contracts.

[0133] A "training dataset" is a collection of diverse sample data used to train a generative AI model.

[0134] ---

[0135] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, performs analysis using a generation AI model, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract.

[0136] Virtual system configuration

[0137] User terminal

[0138] The system provides an interface that allows users to upload contract files, review and apply proposed revisions, and add new clauses.

[0139] server

[0140] The system receives and stores contract files, analyzes them using generative AI models, extracts missing keywords, generates proposed revisions, identifies special clauses, and generates and stores the final version of the contract.

[0141] Specific hardware and software to be used

[0142] Generative AI models: These use pre-trained models such as BERT and GPT.

[0143] Text processing libraries: Libraries such as PDFBox and Tika that convert PDF files into text data.

[0144] User devices: PCs, tablets, smartphones, etc.

[0145] Servers: High-performance computer servers and cloud infrastructure are utilized.

[0146] Program processing

[0147] The user selects a contract file from their device and uploads it to the server by clicking the upload button. The server saves the received contract file and converts it into text data using a text processing library (e.g., PDFBox). This text data is then input into a generative AI model (e.g., BERT) to analyze the structure and content of the contract.

[0148] Based on the analysis results, the server compares them against a list of keywords required for a standard contract and detects any missing keywords. This information is then sent to the user's terminal. The server then generates proposed revisions for any missing parts or clauses that need modification in the contract and presents these to the user.

[0149] Users can review the proposed revisions on their device and choose whether or not to apply them. The server also detects unusual or abnormal clauses within the contract and notifies the user of these as warnings.

[0150] If a user requests the addition of a new clause, they can do so through the input interface on their user terminal. Based on the request, the server generates the new clause and inserts it into the contract. Finally, the server generates and saves the final version of the contract with the modifications and additions completed. The user terminal provides the user with a download link, which the user can click to obtain the final version of the contract.

[0151] Example of a prompt

[0152] Examples of prompts related to contract analysis include the following:

[0153] Analyze the clause regarding "payment terms" in the contract. Check for any missing keywords and propose revisions as needed.

[0154] In this way, the present invention enables the efficient and accurate review, modification, and addition of new clauses to contracts.

[0155] ---

[0156] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0157] Processing steps

[0158] Step 1:

[0159] The user selects the contract file from their device and clicks the upload button.

[0160] Specific steps: Select "Draft Contract.pdf" from the file selection screen and click the upload button. An upload request will be sent to the server.

[0161] Input: Contract file from the user's terminal.

[0162] Output: The contract file is saved on the server.

[0163] Step 2:

[0164] The server saves the received contract file and converts it into text data using a text processing library (e.g., PDFBox).

[0165] Specific action: The server converts "Draft Contract.pdf" into text data.

[0166] Input: Contract file data.

[0167] Output: Text data.

[0168] Step 3:

[0169] The server uses a generative AI model (e.g., BERT) to analyze text data. This analysis classifies the structure and content of the contract.

[0170] Specific operation: Text data is input into the AI ​​model, and outputs such as "Clause 1: Delivery date" and "Clause 2: Payment terms" are obtained.

[0171] Input: Text data.

[0172] Output: Analysis results and classification of articles.

[0173] Step 4:

[0174] The server compares the analysis results against a standard list of keywords required for contracts and extracts any missing keywords.

[0175] Specific operation: The analysis results are compared with a predefined keyword list, and any missing keywords are listed.

[0176] Input: Analysis results, standard keyword list.

[0177] Output: List of missing keywords.

[0178] Step 5:

[0179] The server analyzes the contract to identify any missing sections or clauses that need revision, and generates proposed revisions. These proposed revisions are then presented to the user's terminal.

[0180] Specific operation: Generate proposed corrections for the missing parts and send them to the user's terminal.

[0181] Input: List of missing keywords, analysis results.

[0182] Output: Revision proposal.

[0183] Step 6:

[0184] The user terminal provides an interface that allows the user to review the proposed modifications and choose whether or not to apply them.

[0185] Specific operation: The proposed fix is ​​displayed to the user, and an apply button is provided. When the user clicks the apply button, the result is sent to the server.

[0186] Input: Proposed revision.

[0187] Output: User application confirmation.

[0188] Step 7:

[0189] The server detects unusual or abnormal clauses within the contract and notifies the user's terminal.

[0190] Specific actions: Evaluate the analysis results, list any special clauses, and notify the user's terminal.

[0191] Input: Analysis results.

[0192] Output: Notification of detection of special clauses.

[0193] Step 8:

[0194] The user terminal provides an interface for adding new clauses based on the user's request and sends that request to the server. The server generates the new clauses based on the request and inserts them into the contract.

[0195] Specific operation: Based on the request entered on the user's terminal, the server generates a new clause and inserts it into the contract.

[0196] Input: User's request to add a clause.

[0197] Output: The contract with the new clause added.

[0198] Step 9:

[0199] The server generates and saves the final version of the contract. The final version of the contract is provided to the user's terminal as a download link.

[0200] Specific actions: Generate and save the completed contract in PDF format. Notify the user's terminal of the download link.

[0201] Input: Contract data with corrections and additions completed.

[0202] Output: Final version of the contract file, download link.

[0203] The above outlines the specific steps involved in the system's program processing.

[0204] (Application Example 1)

[0205] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0206] Traditional contract review systems often involved manual analysis, revision, and generation of additional clauses, resulting in inefficiency and inaccuracies. This is particularly problematic in electronic payment services, where new contracts and terms of service updates occur frequently, creating a growing demand for more efficient processes. Furthermore, there was a lack of a way to quickly present analysis results and proposed revisions to users, enabling them to take appropriate action.

[0207] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0208] In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using a generation AI model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for reviewing and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating and inserting new clauses into the contract based on user requests, means for using a presentation device that includes presenting analysis results and proposed revisions, means for generating new clauses using a generation AI model, means for inputting user requests using prompt statements, and means for saving and providing the generated final version of the contract. This makes it possible to efficiently and accurately review, revise, and add new clauses to contracts.

[0209] A "contract file" is an electronic document file that contains the terms and conditions of a contract.

[0210] A "generative AI model" is an artificial intelligence algorithm that learns from large datasets and automatically generates new text and suggestions.

[0211] "Analysis" is the process of examining the structure and content of a contract file, and classifying and understanding the information.

[0212] A "keyword" is a specific word or phrase that holds significant meaning in a contract.

[0213] A "proposal for amendment" refers to changes proposed to improve problems within a contract.

[0214] A "presentation device" is an electronic device used to display analysis results and suggested modifications to the user.

[0215] A "prompt message" is input data used to provide a specific task or information to a generating AI model.

[0216] The "final version" refers to the completed contract after all revisions and additions have been made.

[0217] This invention provides a system for efficiently and accurately reviewing and amending contracts, and is primarily applied to electronic payment services. Specific embodiments of this system are described below.

[0218] System Overview

[0219] This system consists of a user terminal and a server that utilizes a generation AI model. The user terminal provides an interface for uploading contract files, reviewing proposed revisions, and adding new clauses, while the server analyzes the structure and content of the contract and generates and provides proposed revisions and new clauses.

[0220] Hardware and software to be used

[0221] The system uses the following hardware and software:

[0222] User devices: Smartphones, tablets, personal computers

[0223] Server: Cloud server (e.g., AWS®, Google® Cloud)

[0224] Generative AI model: GPT-3 (registered trademark) of OpenAI (registered trademark)

[0225] Analysis and data processing: Python, Flask

[0226] Data storage: Database (e.g., MySQL (registered trademark), PostgreSQL)

[0227] System processing flow

[0228] 1. Upload the contract.

[0229] The user selects a contract file from their terminal and uploads it to the system. The uploaded contract file is sent to the server and converted into text data.

[0230] 2. Analysis of the contract

[0231] The server inputs the received contract file into an AI model that analyzes the structure and content of the contract. This analysis classifies each clause and identifies necessary keywords and items.

[0232] 3. Extraction of missing keywords

[0233] The generative AI model compares the contract to a standard keyword list and extracts any missing keywords. For example, if a "disclaimer clause" is missing, it will notify the user.

[0234] 4. Generating draft amendments to the articles

[0235] Based on the analysis results, the server generates proposed revisions for any missing sections or clauses that need correction. These proposed revisions are then presented to the user's terminal.

[0236] 5. User confirmation and application

[0237] The user reviews the proposed revisions and chooses whether to apply them. Once the revisions are applied, they are reflected in the contract text.

[0238] 6. Identification and notification of special provisions

[0239] The server detects unusual clauses or abnormal content within the contract and displays a warning to the user, thereby reducing the risk associated with the contract.

[0240] 7. Creation and insertion of new articles

[0241] If a user wants to add a new clause to a contract, they input their request as a prompt. The server uses a generative AI model to generate the appropriate clause and insert it into the contract.

[0242] 8. Generation and delivery of the final version

[0243] The server generates and saves the final version of the contract after all revisions and additions have been completed. Users can download the final version.

[0244] Examples of specific cases and prompt statements

[0245] As a concrete example of operation, a user may upload a contract and be notified that a "disclaimer clause" is missing. They can then review the proposed amendment to the disclaimer clause and choose whether to apply it. Furthermore, the process includes entering a request to add a new data protection clause, and inserting the clause generated by the AI ​​generation model into the contract.

[0246] Example of a prompt

[0247] mark down

[0248] Input contract:

[0249] ---

[0250] This agreement is entered into between our company (Party A) and the customer (Party B). It includes the following clauses:

[0251] 1. Contract period

[0252] 2. Payment Terms

[0253] ---

[0254] Missing keywords:

[0255] ---

[0256] mark down

[0257] Input request:

[0258] ---

[0259] I would like to add a new data protection clause.

[0260] ---

[0261] Generated clause:

[0262] ---

[0263] Data Protection Clause: "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy."

[0264] ---

[0265] In this way, the system provides an efficient and accurate way to review, revise, and add new clauses to contracts. This system significantly improves the efficiency and accuracy of contract operations in electronic payment services.

[0266] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0267] Step 1:

[0268] Users select a contract file from their device, such as a smartphone or PC, and upload it to the system. Clicking the upload button sends the file to the server. The server receives the uploaded contract file and converts its contents into text data. The input is a contract file, and the output is text data.

[0269] Step 2:

[0270] The server inputs the received text data into a generating AI model, which analyzes the structure and content of the contract. The AI ​​model classifies each clause within the contract and identifies important keywords and items. The input is text data, and the output is the analysis result.

[0271] Step 3:

[0272] The server compares the analysis results against a standard list of keywords required for a contract and extracts any missing keywords. This information is then communicated to the user. The input is the analysis results, and the output is a list of missing keywords.

[0273] Step 4:

[0274] The server generates proposed revisions for missing keywords and clauses that need correction. The generated proposed revisions are presented to the user's terminal. The input is the analysis results and a list of missing keywords, and the output is the proposed revisions.

[0275] Step 5:

[0276] The user reviews the proposed revisions and chooses whether to apply them. Clicking the "Apply Revisions" button updates the contract. The input is the proposed revisions, and the output is the text data of the revised contract.

[0277] Step 6:

[0278] The server identifies unusual or abnormal clauses within the contract and notifies the user. This warning is displayed on the user's terminal. The input is the analysis result, and the output is the warning message.

[0279] Step 7:

[0280] When a user wants to add a new clause to a contract, the user enters the request as a prompt sentence. The server uses a generative AI model to generate an appropriate clause and inserts it into the contract. The input is the prompt sentence, and the output is the newly generated clause.

[0281] Step 8:

[0282] The server generates the final version of the contract with the amendments and additions completed and saves it in the database. The user can obtain the final version from the download link. The input is the text data of the amended contract, and the output is the contract file of the final version.

[0283] Furthermore, an emotion engine for estimating the user's emotion may be combined. That is, the specific processing unit 290 may estimate the user's emotion using the emotion recognition model 59 and perform specific processing using the user's emotion.

[0284] ---

[0285] The present invention is a system for efficiently and accurately checking and amending a contract. This system can take in a contract file, perform analysis using AI, extract missing keywords, present amendment suggestions for clauses, detect and add special clauses, and generate and save the final contract. Furthermore, it has a function of combining an emotion engine that recognizes the user's emotion and taking corresponding actions according to the user's stress and satisfaction. The specific embodiments of this system will be described below.

[0286] Virtual system configuration

[0287] User terminal

[0288] Provides an interface capable of uploading a contract file, checking and applying amendments, adding new clauses, and recognizing emotions.

[0289] Server

[0290] The system receives and saves contract files, performs AI analysis, extracts missing keywords, generates proposed revisions, identifies special clauses, generates and saves the final version of the contract, and processes emotional data using an emotional engine.

[0291] Program processing and specific examples

[0292] 1. Upload the contract.

[0293] The user terminal has the functionality to send the contract file to the server when the user selects the contract file and clicks the "Upload" button.

[0294] Example: The user selects "Draft Contract.pdf" from their device and clicks the upload button.

[0295] 2. Analysis of the contract

[0296] The server receives and saves the uploaded contract file. The saved file is converted into text data and input into the AI ​​model. The AI ​​model analyzes the structure and content of the contract and classifies each clause.

[0297] Example: The server converts "Draft Contract.pdf" into text data and categorizes it as "Clause 1: Delivery Date" and "Clause 2: Payment Terms".

[0298] 3. Extraction of missing keywords

[0299] Based on the analysis results, the server compares them against a list of keywords required for a standard contract and detects any missing keywords. This information is then notified to the user.

[0300] Example: It was discovered that the contract lacked a "disclaimer clause," and the user was notified with the message, "The disclaimer clause is missing."

[0301] 4. Generating draft amendments to the articles

[0302] The server identifies the missing parts and the clauses that need to be revised from the analysis results of the contract, and generates an amendment. The generated amendment is presented to the user.

[0303] Example: Present an amendment to the user: "As an example of the disclaimer clause, 'In no event shall the company be liable for indirect or consequential damages.'"

[0304] 5. Confirmation by the user

[0305] The user terminal provides an interface that allows the user to confirm the presented amendment and make a choice on whether to apply it.

[0306] Example: The user confirms the presented amendment to the "disclaimer clause" and clicks the apply button.

[0307] 6. Extraction and notification of special clauses

[0308] The server detects content that is not common or abnormal clauses in the contract and displays a warning to the user.

[0309] Example: A "high penalty clause for late delivery" is detected and notified to the user. Warn that "This clause is not included in a general contract."

[0310] 7. Generation and insertion of new clauses

[0311] The user terminal provides a function to add new clauses based on the user's request. The server inserts the generated clauses into the contract.

[0312] Example: When the user inputs a request "want to add a new data protection clause", the server generates "Data protection clause: 'All personal information collected under this contract will be properly handled in accordance with the company's privacy policy.'" and inserts it into the contract.

[0313] 8. Generation and provision of the final version

[0314] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[0315] Example: After the user has finished reviewing the final revisions, the server generates the final version of the contract. The user can then download the final version by clicking the download link.

[0316] 9. Recognition of user emotions by an emotion engine

[0317] The user terminal provides an interface for recognizing the user's emotions. The server uses an emotion engine to analyze the user's facial expressions, voice, and text input.

[0318] Example: While a user is viewing a draft contract, the system recognizes their facial expressions via camera and analyzes their voice to detect if they are experiencing stress.

[0319] 10. Emotion-based responses

[0320] Based on the analysis results from the emotion engine, the server displays a support message if the user is experiencing stress, and recommends applying the suggested fix if the user is highly satisfied.

[0321] For example, if the user is feeling stressed, a support message such as "Do you need help?" is displayed. If the user is highly satisfied, a message such as "Do you want to apply this fix?" is displayed.

[0322] This process allows the system of the present invention to not only review and revise contracts but also to respond to user emotions, thereby improving the user experience.

[0323] The following describes the processing flow.

[0324] Step 1:

[0325] The user selects the contract file from their device's browser and clicks the "Upload" button.

[0326] Specific operation: The user selects a contract file (e.g., PDF or Word file) through a file selection dialog and clicks the upload button in the browser.

[0327] Step 2:

[0328] The terminal sends the selected file to the server.

[0329] Specific operation: The device sends an HTTP request to the server via the internet and attaches the selected contract file.

[0330] Step 3:

[0331] The server receives the contract file, saves it to storage, detects the file format, and then converts it to text format.

[0332] Specific operation: The server saves the file to a specific directory and converts it into text data using OCR (Optical Character Recognition) or other file conversion tools.

[0333] Step 4:

[0334] The server inputs the converted text data into an AI model, which analyzes the structure of the contract and each clause.

[0335] Specific operation: The server supplies text data to the AI ​​model, and the model identifies and classifies each section and clause in the contract.

[0336] Step 5:

[0337] The server compares the analysis results against a list of keywords required for a standard contract and extracts any missing keywords.

[0338] Specific operation: The server compares the contract text with the keyword list and lists any missing keywords.

[0339] Step 6:

[0340] The server notifies the user of a list of missing keywords.

[0341] Specific operation: The server generates a web page to display incomplete keywords on the user interface and presents it to the user.

[0342] Step 7:

[0343] The server automatically generates proposed revisions for any missing or necessary clauses in the contract.

[0344] Specific operation: The server uses a natural language generation (NLG) algorithm to create proposed amendments while referring to standard clause templates.

[0345] Step 8:

[0346] The server presents the generated proposed fixes to the user.

[0347] Specific operation: The server displays a list of proposed fixes as a web page, allowing users to view it.

[0348] Step 9:

[0349] The user reviews the proposed changes and chooses whether to apply them.

[0350] Specific action: The user reviews the proposed changes and accepts them by clicking the apply button.

[0351] Step 10:

[0352] The server identifies any special clauses included in the contract and notifies the user.

[0353] Specific operation: The server uses an AI model to detect abnormal clauses and displays a warning message to the user.

[0354] Step 11:

[0355] The user requests the addition of a new clause.

[0356] Specific action: The user uses a browser input form to enter the content and type of the new clause.

[0357] Step 12:

[0358] The server generates new clauses based on the user's request and inserts them into the contract.

[0359] Specific operation: The server generates a new clause and inserts its content into the appropriate location.

[0360] Step 13:

[0361] The server generates and saves the final version of the contract after all modifications and additions have been completed.

[0362] Specific operation: The server saves the final text data and generates the final version of the contract file.

[0363] Step 14:

[0364] The user reviews and downloads the final version of the contract.

[0365] Specific action: The user clicks the download link for the final version of the contract and saves the file to their device.

[0366] Step 15:

[0367] The user's device provides an interface for recognizing the user's emotions. It acquires facial expressions and voice through the camera and microphone.

[0368] Specific operation: The user's device uses its camera to acquire facial expression data and its microphone to collect audio data.

[0369] Step 16:

[0370] The server uses an emotion engine to analyze the user's facial expression and voice data to determine the user's emotional state.

[0371] Specific operation: The server invokes the emotion engine, analyzes the acquired data, and determines whether the user is stressed, satisfied, etc.

[0372] Step 17:

[0373] The server determines how to respond to the user based on the results of the emotion engine. If the user is stressed, a support message is displayed; if they are satisfied, it recommends that they apply the suggested fixes as is.

[0374] Specific operation: The server generates messages based on the user's emotional state, displaying "Do you need help?" if support is needed, and "Do you want to apply this fix?" if the user is satisfied.

[0375] This process enables the system of the present invention to efficiently and accurately review, revise, add new clauses to, and provide support that responds to the user's emotions.

[0376] (Example 2)

[0377] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the smart device 14 as the "terminal".

[0378] Conventional contract review systems require efficiency and accuracy in analyzing contracts, proposing revisions, and identifying special clauses, which necessitates considerable time and effort. Furthermore, they lack consideration for user emotions, resulting in a poor user experience. This invention aims to solve these problems by providing a system that efficiently and accurately performs contract review and revision work while also considering user emotions.

[0379] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[0380] In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using an AI model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for reviewing and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating new clauses based on user requests and inserting them into the contract, means for saving and providing the generated final version of the contract, means for analyzing the user's emotions using an emotion prediction engine to recognize the user's emotions, and means for providing appropriate responses based on the user's emotions. This makes it possible to efficiently and accurately review and revise contracts, and further improve the user experience.

[0381] A "contract file" refers to an electronic document file containing the details and clauses of a contract.

[0382] An "AI model" is an algorithm trained on machine learning and used to perform a specific task (in this case, analyzing a contract).

[0383] "Analysis results" refer to the output of data analyzed by the AI ​​model, which is information in a format that reveals the structure and content of the contract clauses.

[0384] "Missing keywords" refer to important terms or expressions that should be included in a standard contract structure but are not present in the uploaded contract data.

[0385] A "revised proposal" refers to the suggestions generated by an AI model for addressing shortcomings or improving clauses in a contract.

[0386] A "special clause" refers to a clause that is not included in a typical contract but is written to specify special conditions or provisions in a particular contract.

[0387] An "emotion prediction engine" refers to a technology used to analyze a user's facial expressions, voice, and text input to infer their emotional state.

[0388] The "final version" refers to the final, completed version of the contract after all revisions and additions have been made.

[0389] Modes for carrying out the invention

[0390] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, analyzes them using an AI model, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract. Furthermore, it incorporates an emotion prediction engine to recognize user emotions, enabling it to respond according to the user's stress and satisfaction levels.

[0391] Specific system configuration

[0392] User terminal

[0393] User terminals are used to provide an interface that allows users to upload contract files, review and apply proposed revisions, add new clauses, and recognize emotions. User terminals include common computer devices such as PCs, smartphones, and tablets.

[0394] server

[0395] The server receives and stores contract files, performs AI analysis, extracts missing keywords, generates proposed revisions, identifies special clauses, generates and stores the final version of the contract, and processes sentiment data using a sentiment prediction engine. This utilizes high-performance server machines and dedicated software or cloud services.

[0396] Specifically, it uses Amazon S3 and Google Cloud Storage as storage and the Tesseract OCR engine for text conversion. It also employs generative AI models such as GPT-3 for AI analysis.

[0397] Program Processing Description

[0398] Uploading and receiving contracts

[0399] When the user selects a contract file and clicks the "Upload" button, the user terminal sends the file to the server using an HTTP POST request.

[0400] Example: When a user selects the "Draft Contract.pdf" file and clicks the upload button, the file is sent to the server.

[0401] Saving and converting contract files to text

[0402] The server temporarily stores the received contract file in storage and converts it into text data using the Tesseract OCR engine.

[0403] Example: The server saves "contract.pdf" to storage and converts it into text data using the Tesseract OCR engine.

[0404] Contract analysis and extraction of missing keywords

[0405] The server uses a generative AI model (e.g., GPT-3) to analyze the structure and content of the contract and classify each clause. The analysis results are then compared against a standard keyword list to extract any missing keywords.

[0406] Example: The analysis results yield "Clause 1: Delivery Date" and "Clause 2: Payment Terms," ​​and it is identified that the "Exemption Clause" is missing.

[0407] Generation and presentation of revised proposals

[0408] The server identifies any missing sections or clauses that need correction, generates proposed revisions using a generative AI model, and presents them to the user.

[0409] Example: One of the generated proposed revisions is, "As an example of a disclaimer, 'In no event shall we be liable for any indirect or consequential damages.'"

[0410] Detection and notification of special provisions

[0411] The server detects unusual clauses or unconventional content within the contract and displays a warning to the user.

[0412] Example: Detect a clause regarding high penalties for delayed delivery and notify the user that "this clause is not typically included in standard contracts."

[0413] Generation and insertion of new articles

[0414] The user terminal provides the functionality to add new clauses based on the user's request, and the server inserts the generated clauses into the contract.

[0415] Example: A user requests to add a data protection clause, and the server generates a clause stating, "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy," and inserts it into the agreement.

[0416] Generation and delivery of the final version

[0417] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[0418] Example: The server generates the final version of the contract as "final_contract.pdf" and provides the user with a download link.

[0419] Emotion recognition and response using an emotion prediction engine

[0420] The user terminal uses a camera and microphone to recognize the user's emotions and sends data analyzing facial expressions and voice to the server. The server uses an emotion prediction engine to analyze the user's emotional state and provide appropriate responses.

[0421] Example: If the server detects that the user is experiencing stress through the camera and microphone, it will display a support message saying, "Do you need help?"

[0422] This process allows for efficient and accurate review and revision of contracts, while also enabling responses that take into account the user's feelings.

[0423] Example of a prompt

[0424] "Please generate the following clause to add to the contract: 'Data Protection Clause: All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy.'"

[0425] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0426] Step 1: Upload the contract

[0427] The user terminal allows the user to select a contract file and click the "Upload" button. This action selects the file, and it is sent to the server as an HTTP POST request.

[0428] Input: Contract file (e.g., "Draft Contract.pdf")

[0429] Output: Contract file uploaded to the server

[0430] Specific operation: When the user selects "Draft Contract.pdf" from the file selection dialog on the device and clicks the upload button, the device sends the selected file as a POST request to the URL "https: / / example.com / upload".

[0431] Step 2: Receiving and saving the contract

[0432] The server saves the received contract file to temporary storage. The saved file will be used for future analysis.

[0433] Input: Uploaded contract file

[0434] Output: Contract file saved in storage

[0435] Specific operation: The server saves the received file as "uploads / contract.pdf" to storage.

[0436] Step 3: Convert the contract text

[0437] The server uses OCR (Optical Character Recognition) technology to convert the stored contract files into text data. Here, the Tesseract OCR engine is used.

[0438] Input: Saved contract file

[0439] Output: Contract content converted to text data

[0440] Specific operation: The server converts "contract.pdf" into text data using the Tesseract OCR engine and saves it to its internal database.

[0441] Step 4: Analysis of the contract

[0442] The server inputs text data into an AI model (e.g., GPT-3) to analyze the structure and content of the contract. The analysis results are categorized by clause.

[0443] Input: Contract content converted to text data

[0444] Output: Structured analysis results (e.g., "Clause 1: Delivery Date", "Clause 2: Payment Terms", etc.)

[0445] Specific operation: The server inputs text data into an AI model and obtains results from analyzing and classifying each clause of the contract.

[0446] Step 5: Extracting missing keywords

[0447] The server compares the analysis results with a list of keywords required for a standard contract and detects any missing keywords.

[0448] Input: Structured analysis results, standard keyword list

[0449] Output: List of missing keywords

[0450] Specific operation: The server compares the analysis results with the list in the "standard_keywords.xlsx" file and finds that the "Disclaimer" is missing.

[0451] Step 6: Notification of missing keywords

[0452] The server notifies the user of information regarding missing keywords. This information is sent via API response or WebSocket.

[0453] Input: List of missing keywords

[0454] Output: Notification message to the user

[0455] Specific action: The server sends a notification to the user's terminal via WebSocket stating, "Disclaimer clause is missing."

[0456] Step 7: Generating proposed amendments to the articles

[0457] The server identifies incomplete or missing clauses and generates proposed revisions using a generative AI model (e.g., GPT-3).

[0458] Input: Missing keywords or incomplete clauses

[0459] Output: Generated proposed revisions

[0460] Specific operation: Use a generative AI model to generate the following as an example of a disclaimer: "In no event shall we be liable for any indirect or consequential damages."

[0461] Step 8: Present the revised proposal

[0462] The user terminal presents the generated proposed fixes to the user and provides an interface for review and application. The user can review them and choose whether or not to apply them.

[0463] Input: Generated proposed revisions

[0464] Output: User confirmation and application instructions

[0465] Specific action: The user terminal displays a dialog box asking, "Do you want to apply the proposed amendments to the disclaimer?" and receives the user's selection.

[0466] Step 9: Detection and notification of special provisions

[0467] The server detects unusual clauses or unconventional content within the contract and displays a warning to the user.

[0468] Input: Structured analysis results

[0469] Output: Notification of unusual clauses or unusual content

[0470] Specific action: Detects "high penalty clauses for delayed delivery" and notifies the user that "this clause is not included in typical contracts."

[0471] Step 10: Generating and inserting new clauses

[0472] The user terminal provides the functionality to add new clauses based on the user's request, and the server inserts the generated clauses into the contract.

[0473] Input: User request, generated AI model

[0474] Output: New clauses added to the contract

[0475] Specific operation: The user requests to "add a data protection clause," and the server generates a clause stating, "'All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy.'" and inserts it into the agreement.

[0476] Step 11: Generating and delivering the final version

[0477] The server generates the final version of the contract, after all revisions and additions have been completed, and saves it to storage. The user terminal provides the user with a download link for the final version.

[0478] Input: Completed contract with revisions and additions.

[0479] Output: Final version of the contract, download link

[0480] Specific operation: The server generates the final version of the contract in PDF format, saves it to storage as "final_contract.pdf", and provides the user with a download link.

[0481] Step 12: Emotion Recognition by Emotion Prediction Engine

[0482] The user terminal uses a camera and microphone to recognize the user's emotions, recording their facial expressions and voice and sending them to the server. The server uses an emotion prediction engine to analyze the user's emotional state.

[0483] Input: User facial expression data, voice data

[0484] Output: Analysis results of the user's emotional state

[0485] Specific operation: The user's device uses its camera and microphone to record the user's facial expressions and voice in real time and send them to the server. The server analyzes this data to determine whether the user is experiencing stress.

[0486] Step 13: Emotion-Based Responses

[0487] Based on the analysis results of the emotion prediction engine, the server displays a support message if the user is experiencing stress, and recommends applying the suggested fix if the user is highly satisfied.

[0488] Input: Analysis results of emotional state

[0489] Output: Support message or recommendation to apply a fix to the user.

[0490] Specific actions: If the user is feeling stressed, the message "Do you need help?" will be displayed; if the user is highly satisfied, the message "Do you want to apply this fix?" will be displayed.

[0491] These steps enable the system to efficiently and accurately review and revise contracts, while also providing a user-friendly operating environment that is sensitive to user emotions.

[0492] (Application Example 2)

[0493] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as a "server" and the smart device 14 as a "terminal".

[0494] While systems exist that efficiently and accurately review and revise contracts, very few systems have the functionality to respond based on the user's emotions and stress levels. Furthermore, in today's mobile society, systems that allow contract review and revision in specific environments, such as autonomous vehicles, are limited, and there is a need to improve the user experience. Therefore, there is a need to provide a system that allows users to efficiently review and revise contracts even while on the go, and that can also provide support based on the user's emotions.

[0495] In Application Example 2, the identification processing by the identification processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using an artificial intelligence model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for confirming and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating new clauses based on the user's request and inserting them into the contract, means for saving and providing the generated final version of the contract, means for acquiring the user's image data and voice data, and means for recognizing the user's emotions from the acquired data and responding accordingly. This enables the user to efficiently review and revise contracts even in an autonomous vehicle, and further enables the provision of appropriate support based on the user's emotions.

[0496] A "contract file" is a document file that contains the details of a contract.

[0497] An "artificial intelligence model" refers to a program or algorithm designed to mimic human intelligent behavior.

[0498] "The structure of a contract" refers to the arrangement and organizational structure of chapters and clauses within the contract.

[0499] "Missing keywords" are important words or phrases that are necessary for a standard contract but are missing from current contracts.

[0500] A "proposal for amendment" is a draft or suggestion for improving or modifying the clauses or content within a contract.

[0501] A "special clause" is a clause that specifies particular conditions or provisions that are not included in a typical contract.

[0502] "Image data" refers to photographic and video information acquired by devices such as cameras.

[0503] "Audio data" refers to audio information acquired by devices such as microphones.

[0504] "Emotions" refer to a person's psychological state, and include, for example, joy, sadness, anger, and surprise.

[0505] A "server" is a computer system used for data processing and storage.

[0506] This invention is a system for enabling users to efficiently and accurately review and modify contracts within an autonomous vehicle. Specific embodiments of this system are described below.

[0507] System Configuration

[0508] User terminal:

[0509] This is an in-vehicle interface that allows for uploading contract files, reviewing and applying proposed revisions, adding new clauses, and recognizing emotions.

[0510] server:

[0511] The process involves receiving and saving contract files, analyzing them using artificial intelligence models, extracting missing keywords, generating proposed revisions, identifying special clauses, generating and saving the final version of the contract, and processing sentiment data using a sentiment engine.

[0512] Processing Overview

[0513] 1. Upload the contract.

[0514] The user selects the contract file from a user device such as a tablet or smartphone inside the vehicle and clicks the "Upload" button. This sends the contract file to the server.

[0515] 2. Analysis of the contract

[0516] The server receives and stores the uploaded contract file and converts it into text data. The converted data is then input into an artificial intelligence model to analyze the structure and content of the contract.

[0517] 3. Extraction of missing keywords

[0518] The server compares the analysis results against a list of keywords required for the contract and detects any missing keywords. This result is notified to the user in real time.

[0519] 4. Generating draft amendments to the articles

[0520] The server identifies any deficiencies or inappropriate parts and generates suggested fixes based on those findings. These suggested fixes are then presented to the user through the interface.

[0521] 5. User verification

[0522] The user terminal provides an interface that allows the user to review the proposed corrections and decide whether or not to apply the corrections on the spot.

[0523] 6. Identification and notification of special provisions

[0524] The server detects special clauses within the contract and displays them to the user as warnings or notifications.

[0525] 7. Creation and insertion of new articles

[0526] The user terminal provides the functionality to add new clauses based on user requests. The server inserts the generated clauses into the contract.

[0527] 8. Generation and delivery of the final version

[0528] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[0529] 9. Recognition of user emotions by an emotion engine

[0530] The user terminal collects the user's facial expressions and voice through its camera and microphone. The server recognizes the user's emotions from the acquired data and takes appropriate action based on those emotions.

[0531] 10. Emotion-based responses

[0532] If the user is experiencing stress, the server will display a message asking, "Do you need help?" If the user is highly satisfied, it will recommend applying the suggested fix.

[0533] Hardware and software to use

[0534] Hardware: Cameras, microphones, tablets, smartphones, etc.

[0535] Software: OpenCV (image processing), Keras (deep learning models), Transformers (BERT model), emotion engine.

[0536] Specific example

[0537] Example 1: A user uploads a contract document within the vehicle, and the system automatically suggests any missing items or proposed revisions.

[0538] Example 2: If a user feels stressed while viewing a contract in the vehicle, the camera captures their facial expression and displays the message, "Do you need assistance?"

[0539] Example of a prompt

[0540] If a user experiences stress while reviewing or modifying a contract inside the vehicle, the system should recognize their facial expression via camera and provide an appropriate support message. For example, it could display, "Do you need assistance?"

[0541] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[0542] Step 1:

[0543] The user's terminal uploads the contract file. The user selects the contract file using the interface of their tablet or smartphone and clicks the upload button. This sends the contract file to the server. The input is the contract file selected by the user, and the output is the file being sent to the server.

[0544] Step 2:

[0545] The server receives and saves the uploaded contract file. Next, this file is converted into text data. The input is an uploaded PDF or Word file, and the output is text data. Open-source PDF reading libraries and OCR (Optical Character Recognition) are used for the text conversion.

[0546] Step 3:

[0547] The server inputs text data into an artificial intelligence model, which then analyzes the structure and content of the contract. The input is the converted text data, and the output is the classification results and content analysis results of each clause of the contract. The artificial intelligence model uses a pre-trained dataset and employs natural language processing algorithms such as the BERT model.

[0548] Step 4:

[0549] The server extracts missing keywords based on the analysis results. The input is the contract analysis results and a standard keyword list, and the output is a list of missing keywords. This list is then notified to the user.

[0550] Step 5:

[0551] The server identifies missing sections and clauses requiring revision in the contract and generates proposed revisions. The input is the analysis results and a list of missing keywords; the output is the proposed revisions. These proposed revisions are presented to the user. The generated revisions are created by referencing predefined templates and example sentences.

[0552] Step 6:

[0553] The user terminal reviews the proposed corrections, and the user chooses whether to apply them. The input is the proposed correction information, and the output is the user's selection. The user reviews, applies, and corrects the corrections through the interface.

[0554] Step 7:

[0555] The server identifies and notifies the user of special clauses within the contract. The input is the analysis result, and the output is the detection result of the special clause and a notification message. It refers to a database of laws and regulations to identify unusual clauses.

[0556] Step 8:

[0557] The user terminal provides the functionality to generate and add new clauses based on user requests. The server inserts the generated clauses into the contract. The input is the user's request, and the output is the generated new clauses. A natural language generation model is used to generate the clauses requested by the user.

[0558] Step 9:

[0559] The server generates and saves the final version of the contract after all revisions and additions have been completed. The user terminal provides the user with a download link. The input is the text with all revisions and additions completed, and the output is the final version of the contract file.

[0560] Step 10:

[0561] The user's device uses a camera and microphone to acquire the user's facial expressions and audio data. The input is the video and audio data acquired from the camera and microphone, and the output is the input data for the emotion recognition engine.

[0562] Step 11:

[0563] The server recognizes the user's emotions from acquired video and audio data and responds accordingly. The input is the analysis result from the emotion engine, and the output is an appropriate response message. Emotion recognition uses facial recognition software (e.g., OpenCV) or speech analysis software.

[0564] Example of a prompt

[0565] If a user experiences stress while reviewing or modifying a contract inside the vehicle, the system should recognize their facial expression via camera and provide an appropriate support message. For example, it could display, "Do you need assistance?"

[0566] 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 user input for the result of the specific processing. The control unit 46A transmits the audio data indicating 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.

[0567] Data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of data generation model 58 is ChatGPT (registered trademark) (Internet search).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0568] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the smart device 14.

[0569] [Second Embodiment]

[0570] Figure 3 shows an example of the configuration of the data processing system 210 according to the second embodiment.

[0571] As shown in Figure 3, the data processing system 210 includes a data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0572] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0573] The smart glasses 214 include a computer 36, a microphone 238, a speaker 240, a camera 42, and a communication interface 44. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, and camera 42 are also connected to the bus 52.

[0574] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

[0575] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the area around the user 20 (for example, an imaging range defined by a field of view equivalent to the width of a typical healthy person's field of vision).

[0576] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[0577] Figure 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Figure 4, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[0578] The specific processing program 56 is an example of a "program" relating to the technology of this 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.

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

[0580] In the smart glasses 214, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. 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 processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0581] Next, the identification processing performed by the identification processing unit 290 of the data processing device 12 will be described. 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".

[0582] ---

[0583] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, performs AI-based analysis, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract. Specific embodiments of this system are described below.

[0584] Virtual system configuration

[0585] User terminal

[0586] It provides an interface that allows users to upload contract files, review and apply proposed revisions, and add new clauses.

[0587] server

[0588] The system receives and saves contract files, performs AI analysis, extracts missing keywords, generates proposed revisions, identifies special clauses, and generates and saves the final version of the contract.

[0589] Program processing and specific examples

[0590] 1. Upload the contract.

[0591] The user terminal has the functionality to upload contract files to the server by the user selecting a contract file and clicking a button.

[0592] Example: The user selects "Draft Contract.pdf" from their device and clicks the upload button.

[0593] 2. Analysis of the contract

[0594] The server receives and saves the uploaded contract file. The saved file is converted into text data and input into the AI ​​model. The AI ​​model analyzes the structure and content of the contract and classifies each clause.

[0595] Example: The server converts "Draft Contract.pdf" into text data and categorizes it as "Clause 1: Delivery Date" and "Clause 2: Payment Terms".

[0596] 3. Extraction of missing keywords

[0597] Based on the analysis results, the server compares them against a list of keywords required for a standard contract and detects any missing keywords. This information is then notified to the user.

[0598] Example: It was discovered that the contract lacked a "disclaimer clause," and the user was notified with the message, "The disclaimer clause is missing."

[0599] 4. Generating draft amendments to the articles

[0600] The server analyzes the contract to identify any missing sections or clauses that need revision, and generates a draft revision. The generated draft revision is then presented to the user.

[0601] Example: Present the user with a proposed revision, such as "In no event shall we be liable for any indirect or consequential damages," as an example of a disclaimer.

[0602] 5. User verification

[0603] The user terminal provides an interface that allows the user to review the proposed corrections and choose whether or not to apply them.

[0604] Example: The user reviews the proposed revisions to the "Disclaimer" and clicks the Apply button.

[0605] 6. Extraction and notification of special provisions

[0606] The server detects unusual content or abnormal clauses within the contract and displays a warning to the user.

[0607] Example: A clause containing high penalties for delayed delivery was detected and notified to the user. The system warned that "this clause is not included in typical contracts."

[0608] 7. Creation and insertion of new articles

[0609] The user terminal provides the functionality to add new clauses based on user requests. The server inserts the generated clauses into the contract.

[0610] For example, if a user enters a request to "add a new data protection clause," the server will generate the following data protection clause: "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy," and insert it into the agreement.

[0611] 8. Generation and delivery of the final version

[0612] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[0613] Example: After the user has finished reviewing the final revisions, the server generates the final version of the contract. The user can then download the final version by clicking the download link.

[0614] In this way, the system of the present invention can efficiently and accurately perform the review, modification, and addition of new clauses to contracts.

[0615] The following describes the processing flow.

[0616] Step 1:

[0617] The user selects the contract file from their device's browser and clicks the "Upload" button.

[0618] Specific operation: The user selects a contract file (e.g., PDF or Word file) through a file selection dialog and clicks the upload button in the browser.

[0619] Step 2:

[0620] The terminal sends the selected file to the server.

[0621] Specific operation: The device sends an HTTP request to the server via the internet and attaches the selected contract file.

[0622] Step 3:

[0623] The server receives the contract file, saves it to storage, detects the file format, and then converts it to text format.

[0624] Specific operation: The server saves the file to a specific directory and converts it into text data using OCR (Optical Character Recognition) or other file conversion tools.

[0625] Step 4:

[0626] The server inputs the converted text data into an AI model, which analyzes the structure of the contract and each clause.

[0627] Specific operation: The server supplies text data to the AI ​​model, and the model identifies and classifies each section and clause in the contract.

[0628] Step 5:

[0629] The server compares the analysis results against a list of keywords required for a standard contract and extracts any missing keywords.

[0630] Specific operation: The server compares the contract text with the keyword list and lists any missing keywords.

[0631] Step 6:

[0632] The server notifies the user of a list of missing keywords.

[0633] Specific operation: The server generates a web page to display incomplete keywords on the user interface and presents it to the user.

[0634] Step 7:

[0635] The server automatically generates proposed revisions for any missing or necessary clauses in the contract.

[0636] Specific operation: The server uses a natural language generation (NLG) algorithm to create proposed amendments while referring to standard clause templates.

[0637] Step 8:

[0638] The server presents the generated proposed fixes to the user.

[0639] Specific operation: The server displays a list of proposed fixes as a web page, allowing users to view it.

[0640] Step 9:

[0641] The user reviews the proposed changes and chooses whether to apply them.

[0642] Specific action: The user reviews the proposed changes and accepts them by clicking the apply button.

[0643] Step 10:

[0644] The server identifies any special clauses included in the contract and notifies the user.

[0645] Specific operation: The server uses an AI model to detect abnormal clauses and displays a warning message to the user.

[0646] Step 11:

[0647] The user requests the addition of a new clause.

[0648] Specific action: The user uses a browser input form to enter the content and type of the new clause.

[0649] Step 12:

[0650] The server generates new clauses based on the user's request and inserts them into the contract.

[0651] Specific operation: The server generates a new clause and inserts its content into the appropriate location.

[0652] Step 13:

[0653] The server generates and saves the final version of the contract after all modifications and additions have been completed.

[0654] Specific operation: The server saves the final text data and generates the final version of the contract file.

[0655] Step 14:

[0656] The user reviews and downloads the final version of the contract.

[0657] Specific action: The user clicks the download link for the final version of the contract and saves the file to their device.

[0658] This process allows for efficient and accurate review, revision, detection of special clauses, and addition of new clauses to contracts.

[0659] (Example 1)

[0660] Next, we will describe Example 1. 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".

[0661] Traditional contract review and revision processes are often manual, making them time-consuming, laborious, and prone to human error. Furthermore, it was difficult to quickly and accurately address non-standard contracts or those requiring minor revisions. Advanced tasks such as generating new clauses and detecting and notifying users of special clauses were also extremely cumbersome when performed manually. There is a need for a system that can solve these problems and efficiently and accurately perform contract review, revision, addition of new clauses, and generation of final versions.

[0662] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0663] In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using a generative AI model, means for converting the contract file into text data using a text processing library, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for reviewing and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating and inserting new clauses based on user requests into the contract, means for saving and providing the generated final version of the contract, and means for generating prompt sentences used for analyzing the contract from a training dataset. This makes it possible to efficiently and accurately review, revise, add new clauses, and detect and notify special clauses in contracts.

[0664] A "contract file" is a document containing the details of a contract, stored in an electronic format.

[0665] "Method of uploading" refers to the function that allows users to send contract files from their own devices to the server.

[0666] A "generative AI model" is an artificial intelligence system that has been trained in advance using various datasets, and is used to analyze the structure and content of contracts.

[0667] "Means of analysis" refers to a function that automatically analyzes the content and structure of contract files and extracts necessary information.

[0668] A "text processing library" is a software component used to convert electronic documents into text data.

[0669] "Text data" refers to data that represents the content of a document as a string of characters.

[0670] "Missing keywords" are important words or phrases that should be included in a standard contract but are not present in the contract being analyzed.

[0671] "Means for generating revised proposals" refers to a function that automatically creates specific suggestions for revisions or additions to clauses within a contract when necessary.

[0672] A "user terminal" refers to a device used by a user to perform operations such as uploading contracts, reviewing and applying proposed revisions, and adding new clauses.

[0673] A "special clause" refers to a clause that contains specific conditions or provisions not typically found in standard contracts.

[0674] A "new clause" refers to a clause that is newly added to the contract based on the user's request.

[0675] The "final version of the contract" refers to the final contract file after all revisions and additions have been completed.

[0676] "Means of saving and providing" refers to the function of saving the final generated version of the contract on a server and making it available for users to download.

[0677] A "prompt statement" refers to a question or command input to an AI model, and is a document used for analyzing contracts.

[0678] A "training dataset" is a collection of diverse sample data used to train a generative AI model.

[0679] ---

[0680] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, performs analysis using a generation AI model, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract.

[0681] Virtual system configuration

[0682] User terminal

[0683] The system provides an interface that allows users to upload contract files, review and apply proposed revisions, and add new clauses.

[0684] server

[0685] The system receives and stores contract files, analyzes them using generative AI models, extracts missing keywords, generates proposed revisions, identifies special clauses, and generates and stores the final version of the contract.

[0686] Specific hardware and software to be used

[0687] Generative AI models: These use pre-trained models such as BERT and GPT.

[0688] Text processing libraries: Libraries such as PDFBox and Tika that convert PDF files into text data.

[0689] User devices: PCs, tablets, smartphones, etc.

[0690] Servers: High-performance computer servers and cloud infrastructure are utilized.

[0691] Program processing

[0692] The user selects a contract file from their device and uploads it to the server by clicking the upload button. The server saves the received contract file and converts it into text data using a text processing library (e.g., PDFBox). This text data is then input into a generative AI model (e.g., BERT) to analyze the structure and content of the contract.

[0693] Based on the analysis results, the server compares them against a list of keywords required for a standard contract and detects any missing keywords. This information is then sent to the user's terminal. The server then generates proposed revisions for any missing parts or clauses that need modification in the contract and presents these to the user.

[0694] Users can review the proposed revisions on their device and choose whether or not to apply them. The server also detects unusual or abnormal clauses within the contract and notifies the user of these as warnings.

[0695] If a user requests the addition of a new clause, they can do so through the input interface on their user terminal. Based on the request, the server generates the new clause and inserts it into the contract. Finally, the server generates and saves the final version of the contract with the modifications and additions completed. The user terminal provides the user with a download link, which the user can click to obtain the final version of the contract.

[0696] Example of a prompt

[0697] Examples of prompts related to contract analysis include the following:

[0698] Analyze the clause regarding "payment terms" in the contract. Check for any missing keywords and propose revisions as needed.

[0699] In this way, the present invention enables the efficient and accurate review, modification, and addition of new clauses to contracts.

[0700] ---

[0701] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0702] Processing steps

[0703] Step 1:

[0704] The user selects the contract file from their device and clicks the upload button.

[0705] Specific steps: Select "Draft Contract.pdf" from the file selection screen and click the upload button. An upload request will be sent to the server.

[0706] Input: Contract file from the user's terminal.

[0707] Output: The contract file is saved on the server.

[0708] Step 2:

[0709] The server saves the received contract file and converts it into text data using a text processing library (e.g., PDFBox).

[0710] Specific action: The server converts "Draft Contract.pdf" into text data.

[0711] Input: Contract file data.

[0712] Output: Text data.

[0713] Step 3:

[0714] The server uses a generative AI model (e.g., BERT) to analyze text data. This analysis classifies the structure and content of the contract.

[0715] Specific operation: Text data is input into the AI ​​model, and outputs such as "Clause 1: Delivery date" and "Clause 2: Payment terms" are obtained.

[0716] Input: Text data.

[0717] Output: Analysis results and classification of articles.

[0718] Step 4:

[0719] The server compares the analysis results against a standard list of keywords required for contracts and extracts any missing keywords.

[0720] Specific operation: The analysis results are compared with a predefined keyword list, and any missing keywords are listed.

[0721] Input: Analysis results, standard keyword list.

[0722] Output: List of missing keywords.

[0723] Step 5:

[0724] The server analyzes the contract to identify any missing sections or clauses that need revision, and generates proposed revisions. These proposed revisions are then presented to the user's terminal.

[0725] Specific operation: Generate proposed corrections for the missing parts and send them to the user's terminal.

[0726] Input: List of missing keywords, analysis results.

[0727] Output: Revision proposal.

[0728] Step 6:

[0729] The user terminal provides an interface that allows the user to review the proposed modifications and choose whether or not to apply them.

[0730] Specific operation: The proposed fix is ​​displayed to the user, and an apply button is provided. When the user clicks the apply button, the result is sent to the server.

[0731] Input: Proposed revision.

[0732] Output: User application confirmation.

[0733] Step 7:

[0734] The server detects unusual or abnormal clauses within the contract and notifies the user's terminal.

[0735] Specific actions: Evaluate the analysis results, list any special clauses, and notify the user's terminal.

[0736] Input: Analysis results.

[0737] Output: Notification of detection of special clauses.

[0738] Step 8:

[0739] The user terminal provides an interface for adding new clauses based on the user's request and sends that request to the server. The server generates the new clauses based on the request and inserts them into the contract.

[0740] Specific operation: Based on the request entered on the user's terminal, the server generates a new clause and inserts it into the contract.

[0741] Input: User's request to add a clause.

[0742] Output: The contract with the new clause added.

[0743] Step 9:

[0744] The server generates and saves the final version of the contract. The final version of the contract is provided to the user's terminal as a download link.

[0745] Specific actions: Generate and save the completed contract in PDF format. Notify the user's terminal of the download link.

[0746] Input: Contract data with corrections and additions completed.

[0747] Output: Final version of the contract file, download link.

[0748] The above outlines the specific steps involved in the system's program processing.

[0749] (Application Example 1)

[0750] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[0751] Traditional contract review systems often involved manual analysis, revision, and generation of additional clauses, resulting in inefficiency and inaccuracies. This is particularly problematic in electronic payment services, where new contracts and terms of service updates occur frequently, creating a growing demand for more efficient processes. Furthermore, there was a lack of a way to quickly present analysis results and proposed revisions to users, enabling them to take appropriate action.

[0752] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0753] In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using a generation AI model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for reviewing and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating and inserting new clauses into the contract based on user requests, means for using a presentation device that includes presenting analysis results and proposed revisions, means for generating new clauses using a generation AI model, means for inputting user requests using prompt statements, and means for saving and providing the generated final version of the contract. This makes it possible to efficiently and accurately review, revise, and add new clauses to contracts.

[0754] A "contract file" is an electronic document file that contains the terms and conditions of a contract.

[0755] A "generative AI model" is an artificial intelligence algorithm that learns from large datasets and automatically generates new text and suggestions.

[0756] "Analysis" is the process of examining the structure and content of a contract file, and classifying and understanding the information.

[0757] A "keyword" is a specific word or phrase that holds significant meaning in a contract.

[0758] A "proposal for amendment" refers to changes proposed to improve problems within a contract.

[0759] A "presentation device" is an electronic device used to display analysis results and suggested modifications to the user.

[0760] A "prompt message" is input data used to provide a specific task or information to a generating AI model.

[0761] The "final version" refers to the completed contract after all revisions and additions have been made.

[0762] This invention provides a system for efficiently and accurately reviewing and amending contracts, and is primarily applied to electronic payment services. Specific embodiments of this system are described below.

[0763] System Overview

[0764] This system consists of a user terminal and a server that utilizes a generation AI model. The user terminal provides an interface for uploading contract files, reviewing proposed revisions, and adding new clauses, while the server analyzes the structure and content of the contract and generates and provides proposed revisions and new clauses.

[0765] Hardware and software to be used

[0766] The system uses the following hardware and software:

[0767] User devices: Smartphones, tablets, personal computers

[0768] Server: Cloud server (e.g., AWS, Google Cloud)

[0769] Generative AI model: OpenAI's GPT-3

[0770] Analysis and data processing: Python, Flask

[0771] Data storage: Database (e.g., MySQL, PostgreSQL)

[0772] System processing flow

[0773] 1. Upload the contract.

[0774] The user selects a contract file from their terminal and uploads it to the system. The uploaded contract file is sent to the server and converted into text data.

[0775] 2. Analysis of the contract

[0776] The server inputs the received contract file into an AI model that analyzes the structure and content of the contract. This analysis classifies each clause and identifies necessary keywords and items.

[0777] 3. Extraction of missing keywords

[0778] The generative AI model compares the contract to a standard keyword list and extracts any missing keywords. For example, if a "disclaimer clause" is missing, it will notify the user.

[0779] 4. Generating draft amendments to the articles

[0780] Based on the analysis results, the server generates proposed revisions for any missing sections or clauses that need correction. These proposed revisions are then presented to the user's terminal.

[0781] 5. User confirmation and application

[0782] The user reviews the proposed revisions and chooses whether to apply them. Once the revisions are applied, they are reflected in the contract text.

[0783] 6. Identification and notification of special provisions

[0784] The server detects unusual clauses or abnormal content within the contract and displays a warning to the user, thereby reducing the risk associated with the contract.

[0785] 7. Creation and insertion of new articles

[0786] If a user wants to add a new clause to a contract, they input their request as a prompt. The server uses a generative AI model to generate the appropriate clause and insert it into the contract.

[0787] 8. Generation and delivery of the final version

[0788] The server generates and saves the final version of the contract after all revisions and additions have been completed. Users can download the final version.

[0789] Examples of specific cases and prompt statements

[0790] As a concrete example of operation, a user may upload a contract and be notified that a "disclaimer clause" is missing. They can then review the proposed amendment to the disclaimer clause and choose whether to apply it. Furthermore, the process includes entering a request to add a new data protection clause, and inserting the clause generated by the AI ​​generation model into the contract.

[0791] Example of a prompt

[0792] mark down

[0793] Input contract:

[0794] ---

[0795] This agreement is entered into between our company (Party A) and the customer (Party B). It includes the following clauses:

[0796] 1. Contract period

[0797] 2. Payment Terms

[0798] ---

[0799] Missing keywords:

[0800] ---

[0801] mark down

[0802] Input request:

[0803] ---

[0804] I would like to add a new data protection clause.

[0805] ---

[0806] Generated clause:

[0807] ---

[0808] Data Protection Clause: "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy."

[0809] ---

[0810] In this way, the system provides an efficient and accurate way to review, revise, and add new clauses to contracts. This system significantly improves the efficiency and accuracy of contract operations in electronic payment services.

[0811] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0812] Step 1:

[0813] Users select a contract file from their device, such as a smartphone or PC, and upload it to the system. Clicking the upload button sends the file to the server. The server receives the uploaded contract file and converts its contents into text data. The input is a contract file, and the output is text data.

[0814] Step 2:

[0815] The server inputs the received text data into a generating AI model, which analyzes the structure and content of the contract. The AI ​​model classifies each clause within the contract and identifies important keywords and items. The input is text data, and the output is the analysis result.

[0816] Step 3:

[0817] The server compares the analysis results against a standard list of keywords required for a contract and extracts any missing keywords. This information is then communicated to the user. The input is the analysis results, and the output is a list of missing keywords.

[0818] Step 4:

[0819] The server generates proposed revisions for missing keywords and clauses that need correction. The generated proposed revisions are presented to the user's terminal. The input is the analysis results and a list of missing keywords, and the output is the proposed revisions.

[0820] Step 5:

[0821] The user reviews the proposed revisions and chooses whether to apply them. Clicking the "Apply Revisions" button updates the contract. The input is the proposed revisions, and the output is the text data of the revised contract.

[0822] Step 6:

[0823] The server identifies unusual or abnormal clauses within the contract and notifies the user. This warning is displayed on the user's terminal. The input is the analysis result, and the output is the warning message.

[0824] Step 7:

[0825] If a user wants to add a new clause to a contract, they enter the request as a prompt. The server uses a generative AI model to generate the appropriate clause and insert it into the contract. The input is the prompt, and the output is the newly generated clause.

[0826] Step 8:

[0827] The server generates the final version of the contract after all revisions and additions have been completed and saves it to the database. Users can obtain the final version via a download link. The input is the text data of the revised contract, and the output is the final version of the contract file.

[0828] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[0829] ---

[0830] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, performs AI-based analysis, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract. Furthermore, it incorporates an emotion engine that recognizes user emotions, enabling it to respond according to the user's stress and satisfaction levels. Specific embodiments of this system are described below.

[0831] Virtual system configuration

[0832] User terminal

[0833] It provides an interface that allows users to upload contract files, review and apply proposed revisions, add new clauses, and recognize emotions.

[0834] server

[0835] The system receives and saves contract files, performs AI analysis, extracts missing keywords, generates proposed revisions, identifies special clauses, generates and saves the final version of the contract, and processes emotional data using an emotional engine.

[0836] Program processing and specific examples

[0837] 1. Upload the contract.

[0838] The user terminal has the functionality to send the contract file to the server when the user selects the contract file and clicks the "Upload" button.

[0839] Example: The user selects "Draft Contract.pdf" from their device and clicks the upload button.

[0840] 2. Analysis of the contract

[0841] The server receives and saves the uploaded contract file. The saved file is converted into text data and input into the AI ​​model. The AI ​​model analyzes the structure and content of the contract and classifies each clause.

[0842] Example: The server converts "Draft Contract.pdf" into text data and categorizes it as "Clause 1: Delivery Date" and "Clause 2: Payment Terms".

[0843] 3. Extraction of missing keywords

[0844] Based on the analysis results, the server compares them against a list of keywords required for a standard contract and detects any missing keywords. This information is then notified to the user.

[0845] Example: It was discovered that the contract lacked a "disclaimer clause," and the user was notified with the message, "The disclaimer clause is missing."

[0846] 4. Generating draft amendments to the articles

[0847] The server analyzes the contract to identify any missing sections or clauses that need revision, and generates a draft revision. The generated draft revision is then presented to the user.

[0848] Example: Present the user with a proposed revision, such as "In no event shall we be liable for any indirect or consequential damages," as an example of a disclaimer.

[0849] 5. User verification

[0850] The user terminal provides an interface that allows the user to review the proposed corrections and choose whether or not to apply them.

[0851] Example: The user reviews the proposed revisions to the "Disclaimer" and clicks the Apply button.

[0852] 6. Extraction and notification of special provisions

[0853] The server detects unusual content or abnormal clauses within the contract and displays a warning to the user.

[0854] Example: A clause containing high penalties for delayed delivery was detected and notified to the user. The system warned that "this clause is not included in typical contracts."

[0855] 7. Creation and insertion of new articles

[0856] The user terminal provides the functionality to add new clauses based on user requests. The server inserts the generated clauses into the contract.

[0857] For example, if a user enters a request to "add a new data protection clause," the server will generate the following data protection clause: "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy," and insert it into the agreement.

[0858] 8. Generation and delivery of the final version

[0859] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[0860] Example: After the user has finished reviewing the final revisions, the server generates the final version of the contract. The user can then download the final version by clicking the download link.

[0861] 9. Recognition of user emotions by an emotion engine

[0862] The user terminal provides an interface for recognizing the user's emotions. The server uses an emotion engine to analyze the user's facial expressions, voice, and text input.

[0863] Example: While a user is viewing a draft contract, the system recognizes their facial expressions via camera and analyzes their voice to detect if they are experiencing stress.

[0864] 10. Emotion-based responses

[0865] Based on the analysis results from the emotion engine, the server displays a support message if the user is experiencing stress, and recommends applying the suggested fix if the user is highly satisfied.

[0866] For example, if the user is feeling stressed, a support message such as "Do you need help?" is displayed. If the user is highly satisfied, a message such as "Do you want to apply this fix?" is displayed.

[0867] This process allows the system of the present invention to not only review and revise contracts but also to respond to user emotions, thereby improving the user experience.

[0868] The following describes the processing flow.

[0869] Step 1:

[0870] The user selects the contract file from their device's browser and clicks the "Upload" button.

[0871] Specific operation: The user selects a contract file (e.g., PDF or Word file) through a file selection dialog and clicks the upload button in the browser.

[0872] Step 2:

[0873] The terminal sends the selected file to the server.

[0874] Specific operation: The device sends an HTTP request to the server via the internet and attaches the selected contract file.

[0875] Step 3:

[0876] The server receives the contract file, saves it to storage, detects the file format, and then converts it to text format.

[0877] Specific operation: The server saves the file to a specific directory and converts it into text data using OCR (Optical Character Recognition) or other file conversion tools.

[0878] Step 4:

[0879] The server inputs the converted text data into an AI model, which analyzes the structure of the contract and each clause.

[0880] Specific operation: The server supplies text data to the AI ​​model, and the model identifies and classifies each section and clause in the contract.

[0881] Step 5:

[0882] The server compares the analysis results against a list of keywords required for a standard contract and extracts any missing keywords.

[0883] Specific operation: The server compares the contract text with the keyword list and lists any missing keywords.

[0884] Step 6:

[0885] The server notifies the user of a list of missing keywords.

[0886] Specific operation: The server generates a web page to display incomplete keywords on the user interface and presents it to the user.

[0887] Step 7:

[0888] The server automatically generates proposed revisions for any missing or necessary clauses in the contract.

[0889] Specific operation: The server uses a natural language generation (NLG) algorithm to create proposed amendments while referring to standard clause templates.

[0890] Step 8:

[0891] The server presents the generated proposed fixes to the user.

[0892] Specific operation: The server displays a list of proposed fixes as a web page, allowing users to view it.

[0893] Step 9:

[0894] The user reviews the proposed changes and chooses whether to apply them.

[0895] Specific action: The user reviews the proposed changes and accepts them by clicking the apply button.

[0896] Step 10:

[0897] The server identifies any special clauses included in the contract and notifies the user.

[0898] Specific operation: The server uses an AI model to detect abnormal clauses and displays a warning message to the user.

[0899] Step 11:

[0900] The user requests the addition of a new clause.

[0901] Specific action: The user uses a browser input form to enter the content and type of the new clause.

[0902] Step 12:

[0903] The server generates new clauses based on the user's request and inserts them into the contract.

[0904] Specific operation: The server generates a new clause and inserts its content into the appropriate location.

[0905] Step 13:

[0906] The server generates and saves the final version of the contract after all modifications and additions have been completed.

[0907] Specific operation: The server saves the final text data and generates the final version of the contract file.

[0908] Step 14:

[0909] The user reviews and downloads the final version of the contract.

[0910] Specific action: The user clicks the download link for the final version of the contract and saves the file to their device.

[0911] Step 15:

[0912] The user's device provides an interface for recognizing the user's emotions. It acquires facial expressions and voice through the camera and microphone.

[0913] Specific operation: The user's device uses its camera to acquire facial expression data and its microphone to collect audio data.

[0914] Step 16:

[0915] The server uses an emotion engine to analyze the user's facial expression and voice data to determine the user's emotional state.

[0916] Specific operation: The server invokes the emotion engine, analyzes the acquired data, and determines whether the user is stressed, satisfied, etc.

[0917] Step 17:

[0918] The server determines how to respond to the user based on the results of the emotion engine. If the user is feeling stressed, a support message is displayed; if they are satisfied, it recommends that they apply the suggested fixes.

[0919] Specific operation: The server generates messages based on the user's emotional state, displaying "Do you need help?" if support is needed, and "Do you want to apply this fix?" if the user is satisfied.

[0920] This process enables the system of the present invention to efficiently and accurately review, revise, add new clauses to, and provide support that responds to the user's emotions.

[0921] (Example 2)

[0922] Next, we will describe Example 2. 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".

[0923] Conventional contract review systems require efficiency and accuracy in analyzing contracts, proposing revisions, and identifying special clauses, which necessitates considerable time and effort. Furthermore, they lack consideration for user emotions, resulting in a poor user experience. This invention aims to solve these problems by providing a system that efficiently and accurately performs contract review and revision work while also considering user emotions.

[0924] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[0925] In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using an AI model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for reviewing and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating new clauses based on user requests and inserting them into the contract, means for saving and providing the generated final version of the contract, means for analyzing the user's emotions using an emotion prediction engine to recognize the user's emotions, and means for providing appropriate responses based on the user's emotions. This makes it possible to efficiently and accurately review and revise contracts, and further improve the user experience.

[0926] A "contract file" refers to an electronic document file containing the details and clauses of a contract.

[0927] An "AI model" is an algorithm trained on machine learning and used to perform a specific task (in this case, analyzing a contract).

[0928] "Analysis results" refer to the output of data analyzed by the AI ​​model, which is information in a format that reveals the structure and content of the contract clauses.

[0929] "Missing keywords" refer to important terms or expressions that should be included in a standard contract structure but are not present in the uploaded contract data.

[0930] A "revised proposal" refers to the suggestions generated by an AI model for addressing shortcomings or improving clauses in a contract.

[0931] A "special clause" refers to a clause that is not included in a typical contract but is written to specify special conditions or provisions in a particular contract.

[0932] An "emotion prediction engine" refers to a technology used to analyze a user's facial expressions, voice, and text input to infer their emotional state.

[0933] The "final version" refers to the final, completed version of the contract after all revisions and additions have been made.

[0934] Modes for carrying out the invention

[0935] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, analyzes them using an AI model, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract. Furthermore, it incorporates an emotion prediction engine to recognize user emotions, enabling it to respond according to the user's stress and satisfaction levels.

[0936] Specific system configuration

[0937] User terminal

[0938] User terminals are used to provide an interface that allows users to upload contract files, review and apply proposed revisions, add new clauses, and recognize emotions. User terminals include common computer devices such as PCs, smartphones, and tablets.

[0939] server

[0940] The server receives and stores contract files, performs AI analysis, extracts missing keywords, generates proposed revisions, identifies special clauses, generates and stores the final version of the contract, and processes sentiment data using a sentiment prediction engine. This utilizes high-performance server machines and dedicated software or cloud services.

[0941] Specifically, it uses Amazon S3 and Google Cloud Storage as storage and the Tesseract OCR engine for text conversion. It also employs generative AI models such as GPT-3 for AI analysis.

[0942] Program Processing Description

[0943] Uploading and receiving contracts

[0944] When the user selects a contract file and clicks the "Upload" button, the user terminal sends the file to the server using an HTTP POST request.

[0945] Example: When a user selects the "Draft Contract.pdf" file and clicks the upload button, the file is sent to the server.

[0946] Saving and converting contract files to text

[0947] The server temporarily stores the received contract file in storage and converts it into text data using the Tesseract OCR engine.

[0948] Example: The server saves "contract.pdf" to storage and converts it into text data using the Tesseract OCR engine.

[0949] Contract analysis and extraction of missing keywords

[0950] The server uses a generative AI model (e.g., GPT-3) to analyze the structure and content of the contract and classify each clause. The analysis results are then compared against a standard keyword list to extract any missing keywords.

[0951] Example: The analysis results yield "Clause 1: Delivery Date" and "Clause 2: Payment Terms," ​​and it is identified that the "Exemption Clause" is missing.

[0952] Generation and presentation of revised proposals

[0953] The server identifies any missing sections or clauses that need correction, generates proposed revisions using a generative AI model, and presents them to the user.

[0954] Example: One of the generated proposed revisions is, "As an example of a disclaimer, 'In no event shall we be liable for any indirect or consequential damages.'"

[0955] Detection and notification of special provisions

[0956] The server detects unusual clauses or unconventional content within the contract and displays a warning to the user.

[0957] Example: Detect a clause regarding high penalties for delayed delivery and notify the user that "this clause is not typically found in standard contracts."

[0958] Generation and insertion of new articles

[0959] The user terminal provides the functionality to add new clauses based on the user's request, and the server inserts the generated clauses into the contract.

[0960] Example: A user requests to add a data protection clause, and the server generates a clause stating, "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy," and inserts it into the agreement.

[0961] Generation and delivery of the final version

[0962] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[0963] Example: The server generates the final version of the contract as "final_contract.pdf" and provides the user with a download link.

[0964] Emotion recognition and response using an emotion prediction engine

[0965] The user terminal uses a camera and microphone to recognize the user's emotions and sends data analyzing facial expressions and voice to the server. The server uses an emotion prediction engine to analyze the user's emotional state and provide appropriate responses.

[0966] Example: If the server detects that the user is experiencing stress through the camera and microphone, it will display a support message saying, "Do you need help?"

[0967] This process allows for efficient and accurate review and revision of contracts, while also enabling responses that take into account the user's feelings.

[0968] Example of a prompt

[0969] "Please generate the following clause to add to the contract: 'Data Protection Clause: All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy.'"

[0970] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0971] Step 1: Upload the contract

[0972] The user terminal allows the user to select a contract file and click the "Upload" button. This action selects the file, and it is sent to the server as an HTTP POST request.

[0973] Input: Contract file (e.g., "Draft Contract.pdf")

[0974] Output: Contract file uploaded to the server

[0975] Specific operation: When the user selects "Draft Contract.pdf" from the file selection dialog on the device and clicks the upload button, the device sends the selected file as a POST request to the URL "https: / / example.com / upload".

[0976] Step 2: Receiving and saving the contract

[0977] The server saves the received contract file to temporary storage. The saved file will be used for future analysis.

[0978] Input: Uploaded contract file

[0979] Output: Contract file saved in storage

[0980] Specific operation: The server saves the received file as "uploads / contract.pdf" to storage.

[0981] Step 3: Convert the contract text

[0982] The server uses OCR (Optical Character Recognition) technology to convert the stored contract files into text data. Here, the Tesseract OCR engine is used.

[0983] Input: Saved contract file

[0984] Output: Contract content converted to text data

[0985] Specific operation: The server converts "contract.pdf" into text data using the Tesseract OCR engine and saves it to its internal database.

[0986] Step 4: Analysis of the contract

[0987] The server inputs text data into an AI model (e.g., GPT-3) to analyze the structure and content of the contract. The analysis results are categorized by clause.

[0988] Input: Contract content converted to text data

[0989] Output: Structured analysis results (e.g., "Clause 1: Delivery Date", "Clause 2: Payment Terms", etc.)

[0990] Specific operation: The server inputs text data into an AI model and obtains results from analyzing and classifying each clause of the contract.

[0991] Step 5: Extracting missing keywords

[0992] The server compares the analysis results with a list of keywords required for a standard contract and detects any missing keywords.

[0993] Input: Structured analysis results, standard keyword list

[0994] Output: List of missing keywords

[0995] Specific operation: The server compares the analysis results with the list in the "standard_keywords.xlsx" file and finds that the "Disclaimer" is missing.

[0996] Step 6: Notification of missing keywords

[0997] The server notifies the user of information regarding missing keywords. This information is sent via API response or WebSocket.

[0998] Input: List of missing keywords

[0999] Output: Notification message to the user

[1000] Specific action: The server sends a notification to the user's terminal via WebSocket stating, "Disclaimer clause is missing."

[1001] Step 7: Generating proposed amendments to the articles

[1002] The server identifies incomplete or missing clauses and generates proposed revisions using a generative AI model (e.g., GPT-3).

[1003] Input: Missing keywords or incomplete clauses

[1004] Output: Generated proposed revisions

[1005] Specific operation: Use a generative AI model to generate the following as an example of a disclaimer: "In no event shall we be liable for any indirect or consequential damages."

[1006] Step 8: Present the revised proposal

[1007] The user terminal presents the generated proposed fixes to the user and provides an interface for review and application. The user can review them and choose whether or not to apply them.

[1008] Input: Generated proposed revisions

[1009] Output: User confirmation and application instructions

[1010] Specific action: The user terminal displays a dialog box asking, "Do you want to apply the proposed amendments to the disclaimer?" and receives the user's selection.

[1011] Step 9: Detection and notification of special provisions

[1012] The server detects unusual clauses or unconventional content within the contract and displays a warning to the user.

[1013] Input: Structured analysis results

[1014] Output: Notification of unusual clauses or unusual content

[1015] Specific action: Detects "high penalty clauses for delayed delivery" and notifies the user that "this clause is not included in typical contracts."

[1016] Step 10: Generating and inserting new clauses

[1017] The user terminal provides the functionality to add new clauses based on the user's request, and the server inserts the generated clauses into the contract.

[1018] Input: User request, generated AI model

[1019] Output: New clauses added to the contract

[1020] Specific operation: The user requests to "add a data protection clause," and the server generates a clause stating, "'All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy.'" and inserts it into the agreement.

[1021] Step 11: Generating and delivering the final version

[1022] The server generates the final version of the contract, after all revisions and additions have been completed, and saves it to storage. The user terminal provides the user with a download link for the final version.

[1023] Input: Completed contract with revisions and additions.

[1024] Output: Final version of the contract, download link

[1025] Specific operation: The server generates the final version of the contract in PDF format, saves it to storage as "final_contract.pdf", and provides the user with a download link.

[1026] Step 12: Emotion Recognition by Emotion Prediction Engine

[1027] The user terminal uses a camera and microphone to recognize the user's emotions, recording their facial expressions and voice and sending them to the server. The server uses an emotion prediction engine to analyze the user's emotional state.

[1028] Input: User facial expression data, voice data

[1029] Output: Analysis results of the user's emotional state

[1030] Specific operation: The user's device uses its camera and microphone to record the user's facial expressions and voice in real time and send them to the server. The server analyzes this data to determine whether the user is experiencing stress.

[1031] Step 13: Emotion-Based Responses

[1032] Based on the analysis results of the emotion prediction engine, the server displays a support message if the user is experiencing stress, and recommends applying the suggested fix if the user is highly satisfied.

[1033] Input: Analysis results of emotional state

[1034] Output: Support message or recommendation to apply a fix to the user.

[1035] Specific actions: If the user is feeling stressed, the message "Do you need help?" will be displayed; if the user is highly satisfied, the message "Do you want to apply this fix?" will be displayed.

[1036] These steps enable the system to efficiently and accurately review and revise contracts, while also providing a user-friendly operating environment that is sensitive to user emotions.

[1037] (Application Example 2)

[1038] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[1039] While systems exist that efficiently and accurately review and revise contracts, very few systems have the functionality to respond based on the user's emotions and stress levels. Furthermore, in today's mobile society, systems that allow contract review and revision in specific environments, such as autonomous vehicles, are limited, and there is a need to improve the user experience. Therefore, there is a need to provide a system that allows users to efficiently review and revise contracts even while on the go, and that can also provide support based on the user's emotions.

[1040] In Application Example 2, the identification processing by the identification processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using an artificial intelligence model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for confirming and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating new clauses based on the user's request and inserting them into the contract, means for saving and providing the generated final version of the contract, means for acquiring the user's image data and voice data, and means for recognizing the user's emotions from the acquired data and responding accordingly. This enables the user to efficiently review and revise contracts even in an autonomous vehicle, and further enables the provision of appropriate support based on the user's emotions.

[1041] A "contract file" is a document file that contains the details of a contract.

[1042] An "artificial intelligence model" refers to a program or algorithm designed to mimic human intelligent behavior.

[1043] "The structure of a contract" refers to the arrangement and organizational structure of chapters and clauses within the contract.

[1044] "Missing keywords" are important words or phrases that are necessary for a standard contract but are missing from current contracts.

[1045] A "proposal for amendment" is a draft or suggestion for improving or modifying the clauses or content within a contract.

[1046] A "special clause" is a clause that specifies particular conditions or provisions that are not included in a typical contract.

[1047] "Image data" refers to photographic and video information acquired by devices such as cameras.

[1048] "Audio data" refers to audio information acquired by devices such as microphones.

[1049] "Emotions" refer to a person's psychological state, and include, for example, joy, sadness, anger, and surprise.

[1050] A "server" is a computer system used for data processing and storage.

[1051] This invention is a system for enabling users to efficiently and accurately review and modify contracts within an autonomous vehicle. Specific embodiments of this system are described below.

[1052] System Configuration

[1053] User terminal:

[1054] This is an in-vehicle interface that allows for uploading contract files, reviewing and applying proposed revisions, adding new clauses, and recognizing emotions.

[1055] server:

[1056] The process involves receiving and saving contract files, analyzing them using artificial intelligence models, extracting missing keywords, generating proposed revisions, identifying special clauses, generating and saving the final version of the contract, and processing sentiment data using a sentiment engine.

[1057] Processing Overview

[1058] 1. Upload the contract.

[1059] The user selects the contract file from a user device such as a tablet or smartphone inside the vehicle and clicks the "Upload" button. This sends the contract file to the server.

[1060] 2. Analysis of the contract

[1061] The server receives and stores the uploaded contract file and converts it into text data. The converted data is then input into an artificial intelligence model to analyze the structure and content of the contract.

[1062] 3. Extraction of missing keywords

[1063] The server compares the analysis results against a list of keywords required for the contract and detects any missing keywords. This result is notified to the user in real time.

[1064] 4. Generating draft amendments to the articles

[1065] The server identifies any deficiencies or inappropriate parts and generates suggested fixes based on those findings. These suggested fixes are then presented to the user through the interface.

[1066] 5. User verification

[1067] The user terminal provides an interface that allows the user to review the proposed corrections and decide whether or not to apply the corrections on the spot.

[1068] 6. Identification and notification of special provisions

[1069] The server detects special clauses within the contract and displays them to the user as warnings or notifications.

[1070] 7. Creation and insertion of new articles

[1071] The user terminal provides the functionality to add new clauses based on user requests. The server inserts the generated clauses into the contract.

[1072] 8. Generation and delivery of the final version

[1073] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[1074] 9. Recognition of user emotions by an emotion engine

[1075] The user terminal collects the user's facial expressions and voice through its camera and microphone. The server recognizes the user's emotions from the acquired data and takes appropriate action based on those emotions.

[1076] 10. Emotion-based responses

[1077] If the user is experiencing stress, the server will display a message asking, "Do you need help?" If the user is highly satisfied, it will recommend applying the suggested fix.

[1078] Hardware and software to use

[1079] Hardware: Cameras, microphones, tablets, smartphones, etc.

[1080] Software: OpenCV (image processing), Keras (deep learning models), Transformers (BERT model), emotion engine.

[1081] Specific example

[1082] Example 1: A user uploads a contract document within the vehicle, and the system automatically suggests any missing items or proposed revisions.

[1083] Example 2: If a user feels stressed while viewing a contract in the vehicle, the camera captures their facial expression and displays the message, "Do you need assistance?"

[1084] Example of a prompt

[1085] If a user experiences stress while reviewing or modifying a contract inside the vehicle, the system should recognize their facial expression via camera and provide an appropriate support message. For example, it could display, "Do you need assistance?"

[1086] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[1087] Step 1:

[1088] The user's terminal uploads the contract file. The user selects the contract file using the interface of their tablet or smartphone and clicks the upload button. This sends the contract file to the server. The input is the contract file selected by the user, and the output is the file being sent to the server.

[1089] Step 2:

[1090] The server receives and saves the uploaded contract file. Next, this file is converted into text data. The input is an uploaded PDF or Word file, and the output is text data. Open-source PDF reading libraries and OCR (Optical Character Recognition) are used for the text conversion.

[1091] Step 3:

[1092] The server inputs text data into an artificial intelligence model, which then analyzes the structure and content of the contract. The input is the converted text data, and the output is the classification results and content analysis results of each clause of the contract. The artificial intelligence model uses a pre-trained dataset and employs natural language processing algorithms such as the BERT model.

[1093] Step 4:

[1094] The server extracts missing keywords based on the analysis results. The input is the contract analysis results and a standard keyword list, and the output is a list of missing keywords. This list is then notified to the user.

[1095] Step 5:

[1096] The server identifies missing sections and clauses requiring revision in the contract and generates proposed revisions. The input is the analysis results and a list of missing keywords; the output is the proposed revisions. These proposed revisions are presented to the user. The generated revisions are created by referencing predefined templates and example sentences.

[1097] Step 6:

[1098] The user terminal reviews the proposed corrections, and the user chooses whether to apply them. The input is the proposed correction information, and the output is the user's selection. The user reviews, applies, and corrects the corrections through the interface.

[1099] Step 7:

[1100] The server identifies and notifies the user of special clauses within the contract. The input is the analysis result, and the output is the detection result of the special clause and a notification message. It refers to a database of laws and regulations to identify unusual clauses.

[1101] Step 8:

[1102] The user terminal provides the functionality to generate and add new clauses based on user requests. The server inserts the generated clauses into the contract. The input is the user's request, and the output is the generated new clauses. A natural language generation model is used to generate the clauses requested by the user.

[1103] Step 9:

[1104] The server generates and saves the final version of the contract after all revisions and additions have been completed. The user terminal provides the user with a download link. The input is the text with all revisions and additions completed, and the output is the final version of the contract file.

[1105] Step 10:

[1106] The user's device uses a camera and microphone to acquire the user's facial expressions and audio data. The input is the video and audio data acquired from the camera and microphone, and the output is the input data for the emotion recognition engine.

[1107] Step 11:

[1108] The server recognizes the user's emotions from acquired video and audio data and responds accordingly. The input is the analysis result from the emotion engine, and the output is an appropriate response message. Emotion recognition uses facial recognition software (e.g., OpenCV) or speech analysis software.

[1109] Example of a prompt

[1110] If a user experiences stress while reviewing or modifying a contract inside the vehicle, the system should recognize their facial expression via camera and provide an appropriate support message. For example, it could display, "Do you need assistance?"

[1111] 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 user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[1112] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1113] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the smart glasses 214.

[1114] [Third Embodiment]

[1115] Figure 5 shows an example of the configuration of the data processing system 310 according to the third embodiment.

[1116] As shown in Figure 5, the data processing system 310 includes a data processing device 12 and a headset terminal 314. An example of the data processing device 12 is a server.

[1117] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1118] The headset terminal 314 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a display 343. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and display 343 are also connected to the bus 52.

[1119] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

[1120] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the area around the user 20 (for example, an imaging range defined by a field of view equivalent to the width of a typical healthy person's field of vision).

[1121] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[1122] Figure 6 shows an example of the main functions of the data processing device 12 and the headset terminal 314. As shown in Figure 6, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[1123] The specific processing program 56 is an example of a "program" relating to the technology of this 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.

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

[1125] In the headset terminal 314, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. 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 processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[1126] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the headset terminal 314 will be referred to as the "terminal".

[1127] ---

[1128] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, performs AI-based analysis, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract. Specific embodiments of this system are described below.

[1129] Virtual system configuration

[1130] User terminal

[1131] It provides an interface that allows users to upload contract files, review and apply proposed revisions, and add new clauses.

[1132] server

[1133] The system receives and saves contract files, performs AI analysis, extracts missing keywords, generates proposed revisions, identifies special clauses, and generates and saves the final version of the contract.

[1134] Program processing and specific examples

[1135] 1. Upload the contract.

[1136] The user terminal has the functionality to upload contract files to the server by the user selecting a contract file and clicking a button.

[1137] Example: The user selects "Draft Contract.pdf" from their device and clicks the upload button.

[1138] 2. Analysis of the contract

[1139] The server receives and saves the uploaded contract file. The saved file is converted into text data and input into the AI ​​model. The AI ​​model analyzes the structure and content of the contract and classifies each clause.

[1140] Example: The server converts "Draft Contract.pdf" into text data and categorizes it as "Clause 1: Delivery Date" and "Clause 2: Payment Terms".

[1141] 3. Extraction of missing keywords

[1142] Based on the analysis results, the server compares them against a list of keywords required for a standard contract and detects any missing keywords. This information is then notified to the user.

[1143] Example: It was discovered that the contract lacked a "disclaimer clause," and the user was notified with the message, "The disclaimer clause is missing."

[1144] 4. Generating draft amendments to the articles

[1145] The server analyzes the contract to identify any missing sections or clauses that need revision, and generates a draft revision. The generated draft revision is then presented to the user.

[1146] Example: Present the user with a proposed revision, such as "In no event shall we be liable for any indirect or consequential damages," as an example of a disclaimer.

[1147] 5. User verification

[1148] The user terminal provides an interface that allows the user to review the proposed corrections and choose whether or not to apply them.

[1149] Example: The user reviews the proposed revisions to the "Disclaimer" and clicks the Apply button.

[1150] 6. Extraction and notification of special provisions

[1151] The server detects unusual content or abnormal clauses within the contract and displays a warning to the user.

[1152] Example: A clause containing high penalties for delayed delivery was detected and notified to the user. The system warned that "this clause is not included in typical contracts."

[1153] 7. Creation and insertion of new articles

[1154] The user terminal provides the functionality to add new clauses based on user requests. The server inserts the generated clauses into the contract.

[1155] For example, if a user enters a request to "add a new data protection clause," the server will generate the following data protection clause: "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy," and insert it into the agreement.

[1156] 8. Generation and delivery of the final version

[1157] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[1158] Example: After the user has finished reviewing the final revisions, the server generates the final version of the contract. The user can then download the final version by clicking the download link.

[1159] In this way, the system of the present invention can efficiently and accurately perform the review, modification, and addition of new clauses to contracts.

[1160] The following describes the processing flow.

[1161] Step 1:

[1162] The user selects the contract file from their device's browser and clicks the "Upload" button.

[1163] Specific operation: The user selects a contract file (e.g., PDF or Word file) through a file selection dialog and clicks the upload button in the browser.

[1164] Step 2:

[1165] The terminal sends the selected file to the server.

[1166] Specific operation: The device sends an HTTP request to the server via the internet and attaches the selected contract file.

[1167] Step 3:

[1168] The server receives the contract file, saves it to storage, detects the file format, and then converts it to text format.

[1169] Specific operation: The server saves the file to a specific directory and converts it into text data using OCR (Optical Character Recognition) or other file conversion tools.

[1170] Step 4:

[1171] The server inputs the converted text data into an AI model, which analyzes the structure of the contract and each clause.

[1172] Specific operation: The server supplies text data to the AI ​​model, and the model identifies and classifies each section and clause in the contract.

[1173] Step 5:

[1174] The server compares the analysis results against a list of keywords required for a standard contract and extracts any missing keywords.

[1175] Specific operation: The server compares the contract text with the keyword list and lists any missing keywords.

[1176] Step 6:

[1177] The server notifies the user of a list of missing keywords.

[1178] Specific operation: The server generates a web page to display incomplete keywords on the user interface and presents it to the user.

[1179] Step 7:

[1180] The server automatically generates proposed revisions for any missing or necessary clauses in the contract.

[1181] Specific operation: The server uses a natural language generation (NLG) algorithm to create proposed amendments while referring to standard clause templates.

[1182] Step 8:

[1183] The server presents the generated proposed fixes to the user.

[1184] Specific operation: The server displays a list of proposed fixes as a web page, allowing users to view it.

[1185] Step 9:

[1186] The user reviews the proposed changes and chooses whether to apply them.

[1187] Specific action: The user reviews the proposed changes and accepts them by clicking the apply button.

[1188] Step 10:

[1189] The server identifies any special clauses included in the contract and notifies the user.

[1190] Specific operation: The server uses an AI model to detect abnormal clauses and displays a warning message to the user.

[1191] Step 11:

[1192] The user requests the addition of a new clause.

[1193] Specific action: The user uses a browser input form to enter the content and type of the new clause.

[1194] Step 12:

[1195] The server generates new clauses based on the user's request and inserts them into the contract.

[1196] Specific operation: The server generates a new clause and inserts its content into the appropriate location.

[1197] Step 13:

[1198] The server generates and saves the final version of the contract after all modifications and additions have been completed.

[1199] Specific operation: The server saves the final text data and generates the final version of the contract file.

[1200] Step 14:

[1201] The user reviews and downloads the final version of the contract.

[1202] Specific action: The user clicks the download link for the final version of the contract and saves the file to their device.

[1203] This process allows for efficient and accurate review, revision, detection of special clauses, and addition of new clauses to contracts.

[1204] (Example 1)

[1205] Next, we will describe Example 1. 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."

[1206] Traditional contract review and revision processes are often manual, making them time-consuming, laborious, and prone to human error. Furthermore, it was difficult to quickly and accurately address non-standard contracts or those requiring minor revisions. Advanced tasks such as generating new clauses and detecting and notifying users of special clauses were also extremely cumbersome when performed manually. There is a need for a system that can solve these problems and efficiently and accurately perform contract review, revision, addition of new clauses, and generation of final versions.

[1207] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[1208] In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using a generative AI model, means for converting the contract file into text data using a text processing library, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for reviewing and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating and inserting new clauses based on user requests into the contract, means for saving and providing the generated final version of the contract, and means for generating prompt sentences used for analyzing the contract from a training dataset. This makes it possible to efficiently and accurately review, revise, add new clauses, and detect and notify special clauses in contracts.

[1209] A "contract file" is a document containing the details of a contract, stored in an electronic format.

[1210] "Method of uploading" refers to the function that allows users to send contract files from their own devices to the server.

[1211] A "generative AI model" is an artificial intelligence system that has been trained in advance using various datasets, and is used to analyze the structure and content of contracts.

[1212] "Means of analysis" refers to a function that automatically analyzes the content and structure of contract files and extracts necessary information.

[1213] A "text processing library" is a software component used to convert electronic documents into text data.

[1214] "Text data" refers to data that represents the content of a document as a string of characters.

[1215] "Missing keywords" are important words or phrases that should be included in a standard contract but are not present in the contract being analyzed.

[1216] "Means for generating revised proposals" refers to a function that automatically creates specific suggestions for revisions or additions to clauses within a contract when necessary.

[1217] A "user terminal" refers to a device used by a user to perform operations such as uploading contracts, reviewing and applying proposed revisions, and adding new clauses.

[1218] A "special clause" refers to a clause that contains specific conditions or provisions not typically found in standard contracts.

[1219] A "new clause" refers to a clause that is newly added to the contract based on the user's request.

[1220] The "final version of the contract" refers to the final contract file after all revisions and additions have been completed.

[1221] "Means of saving and providing" refers to the function of saving the final generated version of the contract on a server and making it available for users to download.

[1222] A "prompt statement" refers to a question or command input to an AI model, and is a document used for analyzing contracts.

[1223] A "training dataset" is a collection of diverse sample data used to train a generative AI model.

[1224] ---

[1225] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, performs analysis using a generation AI model, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract.

[1226] Virtual system configuration

[1227] User terminal

[1228] The system provides an interface that allows users to upload contract files, review and apply proposed revisions, and add new clauses.

[1229] server

[1230] The system receives and stores contract files, analyzes them using generative AI models, extracts missing keywords, generates proposed revisions, identifies special clauses, and generates and stores the final version of the contract.

[1231] Specific hardware and software to be used

[1232] Generative AI models: These use pre-trained models such as BERT and GPT.

[1233] Text processing libraries: Libraries such as PDFBox and Tika that convert PDF files into text data.

[1234] User devices: PCs, tablets, smartphones, etc.

[1235] Servers: High-performance computer servers and cloud infrastructure are utilized.

[1236] Program processing

[1237] The user selects a contract file from their device and uploads it to the server by clicking the upload button. The server saves the received contract file and converts it into text data using a text processing library (e.g., PDFBox). This text data is then input into a generative AI model (e.g., BERT) to analyze the structure and content of the contract.

[1238] Based on the analysis results, the server compares them against a list of keywords required for a standard contract and detects any missing keywords. This information is then sent to the user's terminal. The server then generates proposed revisions for any missing parts or clauses that need modification in the contract and presents these to the user.

[1239] Users can review the proposed revisions on their device and choose whether or not to apply them. The server also detects unusual or abnormal clauses within the contract and notifies the user of these as warnings.

[1240] If a user requests the addition of a new clause, they can do so through the input interface on their user terminal. Based on the request, the server generates the new clause and inserts it into the contract. Finally, the server generates and saves the final version of the contract with the modifications and additions completed. The user terminal provides the user with a download link, which the user can click to obtain the final version of the contract.

[1241] Example of a prompt

[1242] Examples of prompt messages related to contract analysis include the following:

[1243] Analyze the clause regarding "payment terms" in the contract. Check for any missing keywords and propose revisions as needed.

[1244] In this way, the present invention enables the efficient and accurate review, modification, and addition of new clauses to contracts.

[1245] ---

[1246] The flow of the specific processing in Example 1 will be explained using Figure 11.

[1247] Processing steps

[1248] Step 1:

[1249] The user selects the contract file from their device and clicks the upload button.

[1250] Specific steps: Select "Draft Contract.pdf" from the file selection screen and click the upload button. An upload request will be sent to the server.

[1251] Input: Contract file from the user's terminal.

[1252] Output: The contract file is saved on the server.

[1253] Step 2:

[1254] The server saves the received contract file and converts it into text data using a text processing library (e.g., PDFBox).

[1255] Specific action: The server converts "Draft Contract.pdf" into text data.

[1256] Input: Contract file data.

[1257] Output: Text data.

[1258] Step 3:

[1259] The server uses a generative AI model (e.g., BERT) to analyze text data. This analysis classifies the structure and content of the contract.

[1260] Specific operation: Text data is input into the AI ​​model, and outputs such as "Clause 1: Delivery date" and "Clause 2: Payment terms" are obtained.

[1261] Input: Text data.

[1262] Output: Analysis results and classification of articles.

[1263] Step 4:

[1264] The server compares the analysis results against a standard list of keywords required for contracts and extracts any missing keywords.

[1265] Specific operation: The analysis results are compared with a predefined keyword list, and any missing keywords are listed.

[1266] Input: Analysis results, standard keyword list.

[1267] Output: List of missing keywords.

[1268] Step 5:

[1269] The server analyzes the contract to identify any missing sections or clauses that need revision, and generates proposed revisions. These proposed revisions are then presented to the user's terminal.

[1270] Specific operation: Generate proposed corrections for the missing parts and send them to the user's terminal.

[1271] Input: List of missing keywords, analysis results.

[1272] Output: Revision proposal.

[1273] Step 6:

[1274] The user terminal provides an interface that allows the user to review the proposed modifications and choose whether or not to apply them.

[1275] Specific operation: The proposed fix is ​​displayed to the user, and an apply button is provided. When the user clicks the apply button, the result is sent to the server.

[1276] Input: Proposed revision.

[1277] Output: User application confirmation.

[1278] Step 7:

[1279] The server detects unusual or abnormal clauses within the contract and notifies the user's terminal.

[1280] Specific actions: Evaluate the analysis results, list any special clauses, and notify the user's terminal.

[1281] Input: Analysis results.

[1282] Output: Notification of detection of special clauses.

[1283] Step 8:

[1284] The user terminal provides an interface for adding new clauses based on the user's request and sends that request to the server. The server generates the new clauses based on the request and inserts them into the contract.

[1285] Specific operation: Based on the request entered on the user's terminal, the server generates a new clause and inserts it into the contract.

[1286] Input: User's request to add a clause.

[1287] Output: The contract with the new clause added.

[1288] Step 9:

[1289] The server generates and saves the final version of the contract. The final version of the contract is provided to the user's terminal as a download link.

[1290] Specific actions: Generate and save the completed contract in PDF format. Notify the user's terminal of the download link.

[1291] Input: Contract data with corrections and additions completed.

[1292] Output: Final version of the contract file, download link.

[1293] The above outlines the specific steps involved in the system's program processing.

[1294] (Application Example 1)

[1295] Next, we will explain Application Example 1. In the following explanation, 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."

[1296] Traditional contract review systems often involved manual analysis, revision, and generation of additional clauses, resulting in inefficiency and inaccuracies. This is particularly problematic in electronic payment services, where new contracts and terms of service updates occur frequently, creating a growing demand for more efficient processes. Furthermore, there was a lack of a way to quickly present analysis results and proposed revisions to users, enabling them to take appropriate action.

[1297] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[1298] In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using a generation AI model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for reviewing and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating and inserting new clauses into the contract based on user requests, means for using a presentation device that includes presenting analysis results and proposed revisions, means for generating new clauses using a generation AI model, means for inputting user requests using prompt statements, and means for saving and providing the generated final version of the contract. This makes it possible to efficiently and accurately review, revise, and add new clauses to contracts.

[1299] A "contract file" is an electronic document file that contains the terms and conditions of a contract.

[1300] A "generative AI model" is an artificial intelligence algorithm that learns from large datasets and automatically generates new text and suggestions.

[1301] "Analysis" is the process of examining the structure and content of a contract file, and classifying and understanding the information.

[1302] A "keyword" is a specific word or phrase that has significant meaning in a contract.

[1303] A "proposal for amendment" refers to changes proposed to improve problems within a contract.

[1304] A "presentation device" is an electronic device used to display analysis results and suggested modifications to the user.

[1305] A "prompt message" is input data used to provide a specific task or information to a generating AI model.

[1306] The "final version" refers to the completed contract after all revisions and additions have been made.

[1307] This invention provides a system for efficiently and accurately reviewing and amending contracts, and is primarily applied to electronic payment services. Specific embodiments of this system are described below.

[1308] System Overview

[1309] This system consists of a user terminal and a server that utilizes a generation AI model. The user terminal provides an interface for uploading contract files, reviewing proposed revisions, and adding new clauses, while the server analyzes the structure and content of the contract and generates and provides proposed revisions and new clauses.

[1310] Hardware and software to be used

[1311] The system uses the following hardware and software:

[1312] User devices: Smartphones, tablets, personal computers

[1313] Server: Cloud server (e.g., AWS, Google Cloud)

[1314] Generative AI model: OpenAI's GPT-3

[1315] Analysis and data processing: Python, Flask

[1316] Data storage: Database (e.g., MySQL, PostgreSQL)

[1317] System processing flow

[1318] 1. Upload the contract.

[1319] The user selects a contract file from their terminal and uploads it to the system. The uploaded contract file is sent to the server and converted into text data.

[1320] 2. Analysis of the contract

[1321] The server inputs the received contract file into an AI model that analyzes the structure and content of the contract. This analysis classifies each clause and identifies necessary keywords and items.

[1322] 3. Extraction of missing keywords

[1323] The generative AI model compares the contract to a standard keyword list and extracts any missing keywords. For example, if a "disclaimer clause" is missing, it will notify the user.

[1324] 4. Generating draft amendments to the articles

[1325] Based on the analysis results, the server generates proposed revisions for any missing sections or clauses that need correction. These proposed revisions are then presented to the user's terminal.

[1326] 5. User confirmation and application

[1327] The user reviews the proposed revisions and chooses whether to apply them. Once the revisions are applied, they are reflected in the contract text.

[1328] 6. Identification and notification of special provisions

[1329] The server detects unusual clauses or abnormal content within the contract and displays a warning to the user, thereby reducing the risk associated with the contract.

[1330] 7. Creation and insertion of new articles

[1331] If a user wants to add a new clause to a contract, they input their request as a prompt. The server uses a generative AI model to generate the appropriate clause and insert it into the contract.

[1332] 8. Generation and delivery of the final version

[1333] The server generates and saves the final version of the contract after all revisions and additions have been completed. Users can download the final version.

[1334] Examples of specific cases and prompt statements

[1335] As a concrete example of operation, a user may upload a contract and be notified that a "disclaimer clause" is missing. They can then review the proposed amendment to the disclaimer clause and choose whether to apply it. Furthermore, the process includes entering a request to add a new data protection clause, and inserting the clause generated by the AI ​​generation model into the contract.

[1336] Example of a prompt

[1337] mark down

[1338] Input contract:

[1339] ---

[1340] This agreement is entered into between our company (Party A) and the customer (Party B). It includes the following clauses:

[1341] 1. Contract period

[1342] 2. Payment Terms

[1343] ---

[1344] Missing keywords:

[1345] ---

[1346] mark down

[1347] Input request:

[1348] ---

[1349] I would like to add a new data protection clause.

[1350] ---

[1351] Generated clause:

[1352] ---

[1353] Data Protection Clause: "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy."

[1354] ---

[1355] In this way, the system provides an efficient and accurate way to review, revise, and add new clauses to contracts. This system significantly improves the efficiency and accuracy of contract operations in electronic payment services.

[1356] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[1357] Step 1:

[1358] Users select a contract file from their device, such as a smartphone or PC, and upload it to the system. Clicking the upload button sends the file to the server. The server receives the uploaded contract file and converts its contents into text data. The input is a contract file, and the output is text data.

[1359] Step 2:

[1360] The server inputs the received text data into a generating AI model, which analyzes the structure and content of the contract. The AI ​​model classifies each clause within the contract and identifies important keywords and items. The input is text data, and the output is the analysis result.

[1361] Step 3:

[1362] The server compares the analysis results against a standard list of keywords required for a contract and extracts any missing keywords. This information is then communicated to the user. The input is the analysis results, and the output is a list of missing keywords.

[1363] Step 4:

[1364] The server generates proposed revisions for missing keywords and clauses that need correction. The generated proposed revisions are presented to the user's terminal. The input is the analysis results and a list of missing keywords, and the output is the proposed revisions.

[1365] Step 5:

[1366] The user reviews the proposed revisions and chooses whether to apply them. Clicking the "Apply Revisions" button updates the contract. The input is the proposed revisions, and the output is the text data of the revised contract.

[1367] Step 6:

[1368] The server identifies unusual or abnormal clauses within the contract and notifies the user. This warning is displayed on the user's terminal. The input is the analysis result, and the output is the warning message.

[1369] Step 7:

[1370] If a user wants to add a new clause to a contract, they enter the request as a prompt. The server uses a generative AI model to generate the appropriate clause and insert it into the contract. The input is the prompt, and the output is the newly generated clause.

[1371] Step 8:

[1372] The server generates the final version of the contract after all revisions and additions have been completed and saves it to the database. Users can obtain the final version via a download link. The input is the text data of the revised contract, and the output is the final version of the contract file.

[1373] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[1374] ---

[1375] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, performs AI-based analysis, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract. Furthermore, it incorporates an emotion engine that recognizes user emotions, enabling it to respond according to the user's stress and satisfaction levels. Specific embodiments of this system are described below.

[1376] Virtual system configuration

[1377] User terminal

[1378] It provides an interface that allows users to upload contract files, review and apply proposed revisions, add new clauses, and recognize emotions.

[1379] server

[1380] The system receives and saves contract files, performs AI analysis, extracts missing keywords, generates proposed revisions, identifies special clauses, generates and saves the final version of the contract, and processes emotional data using an emotional engine.

[1381] Program processing and specific examples

[1382] 1. Upload the contract.

[1383] The user terminal has the functionality to send the contract file to the server when the user selects the contract file and clicks the "Upload" button.

[1384] Example: The user selects "Draft Contract.pdf" from their device and clicks the upload button.

[1385] 2. Analysis of the contract

[1386] The server receives and saves the uploaded contract file. The saved file is converted into text data and input into the AI ​​model. The AI ​​model analyzes the structure and content of the contract and classifies each clause.

[1387] Example: The server converts "Draft Contract.pdf" into text data and categorizes it as "Clause 1: Delivery Date" and "Clause 2: Payment Terms".

[1388] 3. Extraction of missing keywords

[1389] Based on the analysis results, the server compares them against a list of keywords required for a standard contract and detects any missing keywords. This information is then notified to the user.

[1390] Example: It was discovered that the contract lacked a "disclaimer clause," and the user was notified with the message, "The disclaimer clause is missing."

[1391] 4. Generating draft amendments to the articles

[1392] The server analyzes the contract to identify any missing sections or clauses that need revision, and generates a draft revision. The generated draft revision is then presented to the user.

[1393] Example: Present the user with a proposed revision, such as "In no event shall we be liable for any indirect or consequential damages," as an example of a disclaimer.

[1394] 5. User verification

[1395] The user terminal provides an interface that allows the user to review the proposed corrections and choose whether or not to apply them.

[1396] Example: The user reviews the proposed revisions to the "Disclaimer" and clicks the Apply button.

[1397] 6. Extraction and notification of special provisions

[1398] The server detects unusual content or abnormal clauses within the contract and displays a warning to the user.

[1399] Example: A clause containing high penalties for delayed delivery was detected and notified to the user. The system warned that "this clause is not included in typical contracts."

[1400] 7. Creation and insertion of new articles

[1401] The user terminal provides the functionality to add new clauses based on user requests. The server inserts the generated clauses into the contract.

[1402] Example: When a user enters a request to "add a new data protection clause," the server generates the following data protection clause: "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy," and inserts it into the agreement.

[1403] 8. Generation and delivery of the final version

[1404] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[1405] Example: After the user has finished reviewing the final revisions, the server generates the final version of the contract. The user can then download the final version by clicking the download link.

[1406] 9. Recognition of user emotions by an emotion engine

[1407] The user terminal provides an interface for recognizing the user's emotions. The server uses an emotion engine to analyze the user's facial expressions, voice, and text input.

[1408] Example: While a user is viewing a draft contract, the system recognizes their facial expressions via camera and analyzes their voice to detect if they are experiencing stress.

[1409] 10. Emotion-based responses

[1410] Based on the analysis results from the emotion engine, the server displays a support message if the user is experiencing stress, and recommends applying the suggested fix if the user is highly satisfied.

[1411] For example, if the user is feeling stressed, a support message such as "Do you need help?" is displayed. If the user is highly satisfied, a message such as "Do you want to apply this fix?" is displayed.

[1412] This process allows the system of the present invention to not only review and revise contracts but also to respond to user emotions, thereby improving the user experience.

[1413] The following describes the processing flow.

[1414] Step 1:

[1415] The user selects the contract file from their device's browser and clicks the "Upload" button.

[1416] Specific operation: The user selects a contract file (e.g., PDF or Word file) through a file selection dialog and clicks the upload button in the browser.

[1417] Step 2:

[1418] The terminal sends the selected file to the server.

[1419] Specific operation: The device sends an HTTP request to the server via the internet and attaches the selected contract file.

[1420] Step 3:

[1421] The server receives the contract file, saves it to storage, detects the file format, and then converts it to text format.

[1422] Specific operation: The server saves the file to a specific directory and converts it into text data using OCR (Optical Character Recognition) or other file conversion tools.

[1423] Step 4:

[1424] The server inputs the converted text data into an AI model, which analyzes the structure of the contract and each clause.

[1425] Specific operation: The server supplies text data to the AI ​​model, and the model identifies and classifies each section and clause in the contract.

[1426] Step 5:

[1427] The server compares the analysis results against a list of keywords required for a standard contract and extracts any missing keywords.

[1428] Specific operation: The server compares the contract text with the keyword list and lists any missing keywords.

[1429] Step 6:

[1430] The server notifies the user of a list of missing keywords.

[1431] Specific operation: The server generates a web page to display incomplete keywords on the user interface and presents it to the user.

[1432] Step 7:

[1433] The server automatically generates proposed revisions for any missing or necessary clauses in the contract.

[1434] Specific operation: The server uses a natural language generation (NLG) algorithm to create proposed amendments while referring to standard clause templates.

[1435] Step 8:

[1436] The server presents the generated proposed fixes to the user.

[1437] Specific operation: The server displays a list of proposed fixes as a web page, allowing users to view it.

[1438] Step 9:

[1439] The user reviews the proposed changes and chooses whether to apply them.

[1440] Specific action: The user reviews the proposed changes and accepts them by clicking the apply button.

[1441] Step 10:

[1442] The server identifies any special clauses included in the contract and notifies the user.

[1443] Specific operation: The server uses an AI model to detect abnormal clauses and displays a warning message to the user.

[1444] Step 11:

[1445] The user requests the addition of a new clause.

[1446] Specific action: The user uses a browser input form to enter the content and type of the new clause.

[1447] Step 12:

[1448] The server generates new clauses based on the user's request and inserts them into the contract.

[1449] Specific operation: The server generates a new clause and inserts its content into the appropriate location.

[1450] Step 13:

[1451] The server generates and saves the final version of the contract after all modifications and additions have been completed.

[1452] Specific operation: The server saves the final text data and generates the final version of the contract file.

[1453] Step 14:

[1454] The user reviews and downloads the final version of the contract.

[1455] Specific action: The user clicks the download link for the final version of the contract and saves the file to their device.

[1456] Step 15:

[1457] The user's device provides an interface for recognizing the user's emotions. It acquires facial expressions and voice through the camera and microphone.

[1458] Specific operation: The user's device uses its camera to acquire facial expression data and its microphone to collect audio data.

[1459] Step 16:

[1460] The server uses an emotion engine to analyze the user's facial expression and voice data to determine the user's emotional state.

[1461] Specific operation: The server invokes the emotion engine, analyzes the acquired data, and determines whether the user is stressed, satisfied, etc.

[1462] Step 17:

[1463] The server determines how to respond to the user based on the results of the emotion engine. If the user is feeling stressed, a support message is displayed; if they are satisfied, it recommends that they apply the suggested fixes.

[1464] Specific operation: The server generates messages based on the user's emotional state, displaying "Do you need help?" if support is needed, and "Do you want to apply this fix?" if the user is satisfied.

[1465] This process enables the system of the present invention to efficiently and accurately review, revise, add new clauses to, and provide support that responds to the user's emotions.

[1466] (Example 2)

[1467] Next, we will describe Example 2. 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."

[1468] Conventional contract review systems require efficiency and accuracy in analyzing contracts, proposing revisions, and identifying special clauses, which necessitates considerable time and effort. Furthermore, they lack consideration for user emotions, resulting in a poor user experience. This invention aims to solve these problems by providing a system that efficiently and accurately performs contract review and revision work while also considering user emotions.

[1469] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[1470] In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using an AI model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for reviewing and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating new clauses based on user requests and inserting them into the contract, means for saving and providing the generated final version of the contract, means for analyzing the user's emotions using an emotion prediction engine to recognize the user's emotions, and means for providing appropriate responses based on the user's emotions. This makes it possible to efficiently and accurately review and revise contracts, and further improve the user experience.

[1471] A "contract file" refers to an electronic document file containing the details and clauses of a contract.

[1472] An "AI model" is an algorithm trained on machine learning and used to perform a specific task (in this case, analyzing a contract).

[1473] "Analysis results" refer to the output of data analyzed by the AI ​​model, which is information in a format that reveals the structure and content of the contract clauses.

[1474] "Missing keywords" refer to important terms or expressions that should be included in a standard contract structure but are not present in the uploaded contract data.

[1475] A "revised proposal" refers to the suggestions generated by an AI model for addressing shortcomings or improving clauses in a contract.

[1476] A "special clause" refers to a clause that is not included in a typical contract but is written to specify special conditions or provisions in a particular contract.

[1477] An "emotion prediction engine" refers to a technology used to analyze a user's facial expressions, voice, and text input to infer their emotional state.

[1478] The "final version" refers to the final, completed version of the contract after all revisions and additions have been made.

[1479] Modes for carrying out the invention

[1480] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, analyzes them using an AI model, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract. Furthermore, it incorporates an emotion prediction engine to recognize user emotions, enabling it to respond according to the user's stress and satisfaction levels.

[1481] Specific system configuration

[1482] User terminal

[1483] User terminals are used to provide an interface that allows users to upload contract files, review and apply proposed revisions, add new clauses, and recognize emotions. User terminals include common computer devices such as PCs, smartphones, and tablets.

[1484] server

[1485] The server receives and stores contract files, performs AI analysis, extracts missing keywords, generates proposed revisions, identifies special clauses, generates and stores the final version of the contract, and processes sentiment data using a sentiment prediction engine. This utilizes high-performance server machines and dedicated software or cloud services.

[1486] Specifically, it uses Amazon S3 and Google Cloud Storage as storage and the Tesseract OCR engine for text conversion. It also employs generative AI models such as GPT-3 for AI analysis.

[1487] Program Processing Description

[1488] Uploading and receiving contracts

[1489] When the user selects a contract file and clicks the "Upload" button, the user terminal sends the file to the server using an HTTP POST request.

[1490] Example: When a user selects the "Draft Contract.pdf" file and clicks the upload button, the file is sent to the server.

[1491] Saving and converting contract files to text

[1492] The server temporarily stores the received contract file in storage and converts it into text data using the Tesseract OCR engine.

[1493] Example: The server saves "contract.pdf" to storage and converts it into text data using the Tesseract OCR engine.

[1494] Contract analysis and extraction of missing keywords

[1495] The server uses a generative AI model (e.g., GPT-3) to analyze the structure and content of the contract and classify each clause. The analysis results are then compared against a standard keyword list to extract any missing keywords.

[1496] Example: The analysis results yield "Clause 1: Delivery Date" and "Clause 2: Payment Terms," ​​and it is identified that the "Exemption Clause" is missing.

[1497] Generation and presentation of revised proposals

[1498] The server identifies any missing sections or clauses that need correction, generates proposed revisions using a generative AI model, and presents them to the user.

[1499] Example: One of the generated proposed revisions is, "As an example of a disclaimer, 'In no event shall we be liable for any indirect or consequential damages.'"

[1500] Detection and notification of special provisions

[1501] The server detects unusual clauses or unconventional content within the contract and displays a warning to the user.

[1502] Example: Detect a clause regarding high penalties for delayed delivery and notify the user that "this clause is not typically found in standard contracts."

[1503] Generation and insertion of new articles

[1504] The user terminal provides the functionality to add new clauses based on the user's request, and the server inserts the generated clauses into the contract.

[1505] Example: A user requests to add a data protection clause, and the server generates a clause stating, "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy," and inserts it into the agreement.

[1506] Generation and delivery of the final version

[1507] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[1508] Example: The server generates the final version of the contract as "final_contract.pdf" and provides the user with a download link.

[1509] Emotion recognition and response using an emotion prediction engine

[1510] The user terminal uses a camera and microphone to recognize the user's emotions and sends data analyzing facial expressions and voice to the server. The server uses an emotion prediction engine to analyze the user's emotional state and provide appropriate responses.

[1511] Example: If the server detects that the user is experiencing stress through the camera and microphone, it will display a support message saying, "Do you need help?"

[1512] This process allows for efficient and accurate review and revision of contracts, while also enabling responses that take into account the user's feelings.

[1513] Example of a prompt

[1514] "Please generate the following clause to add to the contract: 'Data Protection Clause: All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy.'"

[1515] The flow of the specific processing in Example 2 will be explained using Figure 13.

[1516] Step 1: Upload the contract

[1517] The user terminal allows the user to select a contract file and click the "Upload" button. This action selects the file, and it is sent to the server as an HTTP POST request.

[1518] Input: Contract file (e.g., "Draft Contract.pdf")

[1519] Output: Contract file uploaded to the server

[1520] Specific operation: When the user selects "Draft Contract.pdf" from the file selection dialog on the device and clicks the upload button, the device sends the selected file as a POST request to the URL "https: / / example.com / upload".

[1521] Step 2: Receiving and saving the contract

[1522] The server saves the received contract file to temporary storage. The saved file will be used for future analysis.

[1523] Input: Uploaded contract file

[1524] Output: Contract file saved in storage

[1525] Specific operation: The server saves the received file as "uploads / contract.pdf" to storage.

[1526] Step 3: Convert the contract text

[1527] The server uses OCR (Optical Character Recognition) technology to convert the stored contract files into text data. Here, the Tesseract OCR engine is used.

[1528] Input: Saved contract file

[1529] Output: Contract content converted to text data

[1530] Specific operation: The server converts "contract.pdf" into text data using the Tesseract OCR engine and saves it to its internal database.

[1531] Step 4: Analysis of the contract

[1532] The server inputs text data into an AI model (e.g., GPT-3) to analyze the structure and content of the contract. The analysis results are categorized by clause.

[1533] Input: Contract content converted to text data

[1534] Output: Structured analysis results (e.g., "Clause 1: Delivery Date", "Clause 2: Payment Terms", etc.)

[1535] Specific operation: The server inputs text data into an AI model and obtains results from analyzing and classifying each clause of the contract.

[1536] Step 5: Extracting missing keywords

[1537] The server compares the analysis results with a list of keywords required for a standard contract and detects any missing keywords.

[1538] Input: Structured analysis results, standard keyword list

[1539] Output: List of missing keywords

[1540] Specific operation: The server compares the analysis results with the list in the "standard_keywords.xlsx" file and finds that the "Disclaimer" is missing.

[1541] Step 6: Notification of missing keywords

[1542] The server notifies the user of information regarding missing keywords. This information is sent via API response or WebSocket.

[1543] Input: List of missing keywords

[1544] Output: Notification message to the user

[1545] Specific action: The server sends a notification to the user's terminal via WebSocket stating, "Disclaimer clause is missing."

[1546] Step 7: Generating proposed amendments to the articles

[1547] The server identifies incomplete or missing clauses and generates proposed revisions using a generative AI model (e.g., GPT-3).

[1548] Input: Missing keywords or incomplete clauses

[1549] Output: Generated proposed revisions

[1550] Specific operation: Use a generative AI model to generate the following as an example of a disclaimer: "In no event shall we be liable for any indirect or consequential damages."

[1551] Step 8: Present the revised proposal

[1552] The user terminal presents the generated proposed fixes to the user and provides an interface for review and application. The user can review them and choose whether or not to apply them.

[1553] Input: Generated proposed revisions

[1554] Output: User confirmation and application instructions

[1555] Specific action: The user terminal displays a dialog box asking, "Do you want to apply the proposed amendments to the disclaimer?" and receives the user's selection.

[1556] Step 9: Detection and notification of special provisions

[1557] The server detects unusual clauses or unconventional content within the contract and displays a warning to the user.

[1558] Input: Structured analysis results

[1559] Output: Notification of unusual clauses or unusual content

[1560] Specific action: Detects "high penalty clauses for delayed delivery" and notifies the user that "this clause is not included in typical contracts."

[1561] Step 10: Generating and inserting new clauses

[1562] The user terminal provides the functionality to add new clauses based on the user's request, and the server inserts the generated clauses into the contract.

[1563] Input: User request, generated AI model

[1564] Output: New clauses added to the contract

[1565] Specific operation: The user requests to "add a data protection clause," and the server generates a clause stating, "'All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy.'" and inserts it into the agreement.

[1566] Step 11: Generating and delivering the final version

[1567] The server generates the final version of the contract, after all revisions and additions have been completed, and saves it to storage. The user terminal provides the user with a download link for the final version.

[1568] Input: Completed contract with revisions and additions.

[1569] Output: Final version of the contract, download link

[1570] Specific operation: The server generates the final version of the contract in PDF format, saves it to storage as "final_contract.pdf", and provides the user with a download link.

[1571] Step 12: Emotion Recognition by Emotion Prediction Engine

[1572] The user terminal uses a camera and microphone to recognize the user's emotions, recording their facial expressions and voice and sending them to the server. The server uses an emotion prediction engine to analyze the user's emotional state.

[1573] Input: User facial expression data, voice data

[1574] Output: Analysis results of the user's emotional state

[1575] Specific operation: The user's device uses its camera and microphone to record the user's facial expressions and voice in real time and send them to the server. The server analyzes this data to determine whether the user is experiencing stress.

[1576] Step 13: Emotion-Based Responses

[1577] Based on the analysis results of the emotion prediction engine, the server displays a support message if the user is experiencing stress, and recommends applying the suggested fix if the user is highly satisfied.

[1578] Input: Analysis results of emotional state

[1579] Output: Support message or recommendation to apply a fix to the user.

[1580] Specific actions: If the user is feeling stressed, the message "Do you need help?" will be displayed; if the user is highly satisfied, the message "Do you want to apply this fix?" will be displayed.

[1581] These steps enable the system to efficiently and accurately review and revise contracts, while also providing a user-friendly operating environment that is sensitive to user emotions.

[1582] (Application Example 2)

[1583] Next, we will explain application example 2. In the following explanation, 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."

[1584] While systems exist that efficiently and accurately review and revise contracts, very few systems have the functionality to respond based on the user's emotions and stress levels. Furthermore, in today's mobile society, systems that allow contract review and revision in specific environments, such as autonomous vehicles, are limited, and there is a need to improve the user experience. Therefore, there is a need to provide a system that allows users to efficiently review and revise contracts even while on the go, and that can also provide support based on the user's emotions.

[1585] In Application Example 2, the identification processing by the identification processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using an artificial intelligence model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for confirming and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating new clauses based on the user's request and inserting them into the contract, means for saving and providing the generated final version of the contract, means for acquiring the user's image data and voice data, and means for recognizing the user's emotions from the acquired data and responding accordingly. This enables the user to efficiently review and revise contracts even in an autonomous vehicle, and further enables the provision of appropriate support based on the user's emotions.

[1586] A "contract file" is a document file that contains the details of a contract.

[1587] An "artificial intelligence model" refers to a program or algorithm designed to mimic human intelligent behavior.

[1588] "The structure of a contract" refers to the arrangement and organizational structure of chapters and clauses within the contract.

[1589] "Missing keywords" are important words or phrases that are necessary for a standard contract but are missing from current contracts.

[1590] A "proposal for amendment" is a draft or suggestion for improving or modifying the clauses or content within a contract.

[1591] A "special clause" is a clause that specifies particular conditions or provisions that are not included in a typical contract.

[1592] "Image data" refers to photographic and video information acquired by devices such as cameras.

[1593] "Audio data" refers to audio information acquired by devices such as microphones.

[1594] "Emotions" refer to a person's psychological state, and include, for example, joy, sadness, anger, and surprise.

[1595] A "server" is a computer system used for data processing and storage.

[1596] This invention is a system for enabling users to efficiently and accurately review and modify contracts within an autonomous vehicle. Specific embodiments of this system are described below.

[1597] System Configuration

[1598] User terminal:

[1599] This is an in-vehicle interface that allows for uploading contract files, reviewing and applying proposed revisions, adding new clauses, and recognizing emotions.

[1600] server:

[1601] The process involves receiving and saving contract files, analyzing them using artificial intelligence models, extracting missing keywords, generating proposed revisions, identifying special clauses, generating and saving the final version of the contract, and processing sentiment data using a sentiment engine.

[1602] Processing Overview

[1603] 1. Upload the contract.

[1604] The user selects the contract file from a user device such as a tablet or smartphone inside the vehicle and clicks the "Upload" button. This sends the contract file to the server.

[1605] 2. Analysis of the contract

[1606] The server receives and stores the uploaded contract file and converts it into text data. The converted data is then input into an artificial intelligence model to analyze the structure and content of the contract.

[1607] 3. Extraction of missing keywords

[1608] The server compares the analysis results against a list of keywords required for the contract and detects any missing keywords. This result is notified to the user in real time.

[1609] 4. Generating draft amendments to the articles

[1610] The server identifies any deficiencies or inappropriate parts and generates suggested fixes based on those findings. These suggested fixes are then presented to the user through the interface.

[1611] 5. User verification

[1612] The user terminal provides an interface that allows the user to review the proposed corrections and decide whether or not to apply the corrections on the spot.

[1613] 6. Identification and notification of special provisions

[1614] The server detects special clauses within the contract and displays them to the user as warnings or notifications.

[1615] 7. Creation and insertion of new articles

[1616] The user terminal provides the functionality to add new clauses based on user requests. The server inserts the generated clauses into the contract.

[1617] 8. Generation and delivery of the final version

[1618] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[1619] 9. Recognition of user emotions by an emotion engine

[1620] The user terminal collects the user's facial expressions and voice through its camera and microphone. The server recognizes the user's emotions from the acquired data and takes appropriate action based on those emotions.

[1621] 10. Emotion-based responses

[1622] If the user is experiencing stress, the server will display a message asking, "Do you need help?" If the user is highly satisfied, it will recommend applying the suggested fix.

[1623] Hardware and software to use

[1624] Hardware: Cameras, microphones, tablets, smartphones, etc.

[1625] Software: OpenCV (image processing), Keras (deep learning models), Transformers (BERT model), emotion engine.

[1626] Specific example

[1627] Example 1: A user uploads a contract document within the vehicle, and the system automatically suggests any missing items or proposed revisions.

[1628] Example 2: If a user feels stressed while viewing a contract in the vehicle, the camera captures their facial expression and displays the message, "Do you need assistance?"

[1629] Example of a prompt

[1630] If a user experiences stress while reviewing or modifying a contract inside the vehicle, the system should recognize their facial expression via camera and provide an appropriate support message. For example, it could display, "Do you need assistance?"

[1631] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[1632] Step 1:

[1633] The user's terminal uploads the contract file. The user selects the contract file using the interface of their tablet or smartphone and clicks the upload button. This sends the contract file to the server. The input is the contract file selected by the user, and the output is the file being sent to the server.

[1634] Step 2:

[1635] The server receives and saves the uploaded contract file. Next, this file is converted into text data. The input is an uploaded PDF or Word file, and the output is text data. Open-source PDF reading libraries and OCR (Optical Character Recognition) are used for the text conversion.

[1636] Step 3:

[1637] The server inputs text data into an artificial intelligence model, which then analyzes the structure and content of the contract. The input is the converted text data, and the output is the classification results and content analysis results of each clause of the contract. The artificial intelligence model uses a pre-trained dataset and employs natural language processing algorithms such as the BERT model.

[1638] Step 4:

[1639] The server extracts missing keywords based on the analysis results. The input is the contract analysis results and a standard keyword list, and the output is a list of missing keywords. This list is then notified to the user.

[1640] Step 5:

[1641] The server identifies missing sections and clauses requiring revision in the contract and generates proposed revisions. The input is the analysis results and a list of missing keywords; the output is the proposed revisions. These proposed revisions are presented to the user. The generated revisions are created by referencing predefined templates and example sentences.

[1642] Step 6:

[1643] The user terminal reviews the proposed corrections, and the user chooses whether to apply them. The input is the proposed correction information, and the output is the user's selection. The user reviews, applies, and corrects the corrections through the interface.

[1644] Step 7:

[1645] The server identifies and notifies the user of special clauses within the contract. The input is the analysis result, and the output is the detection result of the special clause and a notification message. It refers to a database of laws and regulations to identify unusual clauses.

[1646] Step 8:

[1647] The user terminal provides the functionality to generate and add new clauses based on user requests. The server inserts the generated clauses into the contract. The input is the user's request, and the output is the generated new clauses. A natural language generation model is used to generate the clauses requested by the user.

[1648] Step 9:

[1649] The server generates and saves the final version of the contract after all revisions and additions have been completed. The user terminal provides the user with a download link. The input is the text with all revisions and additions completed, and the output is the final version of the contract file.

[1650] Step 10:

[1651] The user's device uses a camera and microphone to acquire the user's facial expressions and audio data. The input is the video and audio data acquired from the camera and microphone, and the output is the input data for the emotion recognition engine.

[1652] Step 11:

[1653] The server recognizes the user's emotions from acquired video and audio data and responds accordingly. The input is the analysis result from the emotion engine, and the output is an appropriate response message. Emotion recognition uses facial recognition software (e.g., OpenCV) or speech analysis software.

[1654] Example of a prompt

[1655] If a user experiences stress while reviewing or modifying a contract inside the vehicle, the system should recognize their facial expression via camera and provide an appropriate support message. For example, it could display, "Do you need assistance?"

[1656] The specific processing unit 290 transmits the result of the specific processing to the headset terminal 314. In the headset terminal 314, the control unit 46A causes the speaker 240 and display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[1657] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1658] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and specific processing may also be performed by the headset terminal 314.

[1659] [Fourth Embodiment]

[1660] Figure 7 shows an example of the configuration of the data processing system 410 according to the fourth embodiment.

[1661] As shown in Figure 7, the 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.

[1662] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1663] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a controlled object 443. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and controlled object 443 are also connected to the bus 52.

[1664] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

[1665] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the area around the user 20 (for example, an imaging range defined by a field of view equivalent to the width of a typical healthy person's field of vision).

[1666] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[1667] The controlled object 443 includes a display device, LEDs in the eyes, and motors that drive 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 robot 414's emotions can be expressed by controlling these motors. Furthermore, the robot 414's facial expressions can also be expressed by controlling the illumination state of the LEDs in its eyes.

[1668] Figure 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Figure 8, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[1669] The specific processing program 56 is an example of a "program" relating to the technology of this 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.

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

[1671] In robot 414, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. 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 processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[1672] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1673] ---

[1674] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, performs AI-based analysis, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract. Specific embodiments of this system are described below.

[1675] Virtual system configuration

[1676] User terminal

[1677] It provides an interface that allows users to upload contract files, review and apply proposed revisions, and add new clauses.

[1678] server

[1679] The system receives and saves contract files, performs AI analysis, extracts missing keywords, generates proposed revisions, identifies special clauses, and generates and saves the final version of the contract.

[1680] Program processing and specific examples

[1681] 1. Upload the contract.

[1682] The user terminal has the functionality to upload contract files to the server by the user selecting a contract file and clicking a button.

[1683] Example: The user selects "Draft Contract.pdf" from their device and clicks the upload button.

[1684] 2. Analysis of the contract

[1685] The server receives and saves the uploaded contract file. The saved file is converted into text data and input into the AI ​​model. The AI ​​model analyzes the structure and content of the contract and classifies each clause.

[1686] Example: The server converts "Draft Contract.pdf" into text data and categorizes it as "Clause 1: Delivery Date" and "Clause 2: Payment Terms".

[1687] 3. Extraction of missing keywords

[1688] Based on the analysis results, the server compares them against a list of keywords required for a standard contract and detects any missing keywords. This information is then notified to the user.

[1689] Example: It was discovered that the contract lacked a "disclaimer clause," and the user was notified with the message, "The disclaimer clause is missing."

[1690] 4. Generating draft amendments to the articles

[1691] The server analyzes the contract to identify any missing sections or clauses that need revision, and generates a draft revision. The generated draft revision is then presented to the user.

[1692] Example: Present the user with a proposed revision, such as "In no event shall we be liable for any indirect or consequential damages," as an example of a disclaimer.

[1693] 5. User verification

[1694] The user terminal provides an interface that allows the user to review the proposed corrections and choose whether or not to apply them.

[1695] Example: The user reviews the proposed revisions to the "Disclaimer" and clicks the Apply button.

[1696] 6. Extraction and notification of special provisions

[1697] The server detects unusual content or abnormal clauses within the contract and displays a warning to the user.

[1698] Example: A clause containing high penalties for delayed delivery was detected and notified to the user. The system warned that "this clause is not included in typical contracts."

[1699] 7. Creation and insertion of new articles

[1700] The user terminal provides the functionality to add new clauses based on user requests. The server inserts the generated clauses into the contract.

[1701] For example, if a user enters a request to "add a new data protection clause," the server will generate the following data protection clause: "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy," and insert it into the agreement.

[1702] 8. Generation and delivery of the final version

[1703] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[1704] Example: After the user has finished reviewing the final revisions, the server generates the final version of the contract. The user can then download the final version by clicking the download link.

[1705] In this way, the system of the present invention can efficiently and accurately perform the review, modification, and addition of new clauses to contracts.

[1706] The following describes the processing flow.

[1707] Step 1:

[1708] The user selects the contract file from their device's browser and clicks the "Upload" button.

[1709] Specific operation: The user selects a contract file (e.g., PDF or Word file) through a file selection dialog and clicks the upload button in the browser.

[1710] Step 2:

[1711] The terminal sends the selected file to the server.

[1712] Specific operation: The device sends an HTTP request to the server via the internet and attaches the selected contract file.

[1713] Step 3:

[1714] The server receives the contract file, saves it to storage, detects the file format, and then converts it to text format.

[1715] Specific operation: The server saves the file to a specific directory and converts it into text data using OCR (Optical Character Recognition) or other file conversion tools.

[1716] Step 4:

[1717] The server inputs the converted text data into an AI model, which analyzes the structure of the contract and each clause.

[1718] Specific operation: The server supplies text data to the AI ​​model, and the model identifies and classifies each section and clause in the contract.

[1719] Step 5:

[1720] The server compares the analysis results against a list of keywords required for a standard contract and extracts any missing keywords.

[1721] Specific operation: The server compares the contract text with the keyword list and lists any missing keywords.

[1722] Step 6:

[1723] The server notifies the user of a list of missing keywords.

[1724] Specific operation: The server generates a web page to display incomplete keywords on the user interface and presents it to the user.

[1725] Step 7:

[1726] The server automatically generates proposed revisions for any missing or necessary clauses in the contract.

[1727] Specific operation: The server uses a natural language generation (NLG) algorithm to create proposed amendments while referring to standard clause templates.

[1728] Step 8:

[1729] The server presents the generated proposed fixes to the user.

[1730] Specific operation: The server displays a list of proposed fixes as a web page, allowing users to view it.

[1731] Step 9:

[1732] The user reviews the proposed changes and chooses whether to apply them.

[1733] Specific action: The user reviews the proposed changes and accepts them by clicking the apply button.

[1734] Step 10:

[1735] The server identifies any special clauses included in the contract and notifies the user.

[1736] Specific operation: The server uses an AI model to detect abnormal clauses and displays a warning message to the user.

[1737] Step 11:

[1738] The user requests the addition of a new clause.

[1739] Specific action: The user uses a browser input form to enter the content and type of the new clause.

[1740] Step 12:

[1741] The server generates new clauses based on the user's request and inserts them into the contract.

[1742] Specific operation: The server generates a new clause and inserts its content into the appropriate location.

[1743] Step 13:

[1744] The server generates and saves the final version of the contract after all modifications and additions have been completed.

[1745] Specific operation: The server saves the final text data and generates the final version of the contract file.

[1746] Step 14:

[1747] The user reviews and downloads the final version of the contract.

[1748] Specific action: The user clicks the download link for the final version of the contract and saves the file to their device.

[1749] This process allows for efficient and accurate review, revision, detection of special clauses, and addition of new clauses to contracts.

[1750] (Example 1)

[1751] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1752] Traditional contract review and revision processes are often manual, making them time-consuming, laborious, and prone to human error. Furthermore, it was difficult to quickly and accurately address non-standard contracts or those requiring minor revisions. Advanced tasks such as generating new clauses and detecting and notifying users of special clauses were also extremely cumbersome when performed manually. There is a need for a system that can solve these problems and efficiently and accurately perform contract review, revision, addition of new clauses, and generation of final versions.

[1753] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[1754] In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using a generative AI model, means for converting the contract file into text data using a text processing library, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for reviewing and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating and inserting new clauses based on user requests into the contract, means for saving and providing the generated final version of the contract, and means for generating prompt sentences used for analyzing the contract from a training dataset. This makes it possible to efficiently and accurately review, revise, add new clauses, and detect and notify special clauses in contracts.

[1755] A "contract file" is a document containing the details of a contract, stored in an electronic format.

[1756] "Method of uploading" refers to the function that allows users to send contract files from their own devices to the server.

[1757] A "generative AI model" is an artificial intelligence system that has been trained in advance using various datasets, and is used to analyze the structure and content of contracts.

[1758] "Means of analysis" refers to a function that automatically analyzes the content and structure of contract files and extracts necessary information.

[1759] A "text processing library" is a software component used to convert electronic documents into text data.

[1760] "Text data" refers to data that represents the content of a document as a string of characters.

[1761] "Missing keywords" are important words or phrases that should be included in a standard contract but are not present in the contract being analyzed.

[1762] "Means for generating revised proposals" refers to a function that automatically creates specific suggestions for revisions or additions to clauses within a contract when necessary.

[1763] A "user terminal" refers to a device used by a user to perform operations such as uploading contracts, reviewing and applying proposed revisions, and adding new clauses.

[1764] A "special clause" refers to a clause that contains specific conditions or provisions not typically found in standard contracts.

[1765] A "new clause" refers to a clause that is newly added to the contract based on the user's request.

[1766] The "final version of the contract" refers to the final contract file after all revisions and additions have been completed.

[1767] "Means of saving and providing" refers to the function of saving the final generated version of the contract on a server and making it available for users to download.

[1768] A "prompt statement" refers to a question or command input to an AI model, and is a document used for analyzing contracts.

[1769] A "training dataset" is a collection of diverse sample data used to train a generative AI model.

[1770] ---

[1771] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, performs analysis using a generation AI model, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract.

[1772] Virtual system configuration

[1773] User terminal

[1774] The system provides an interface that allows users to upload contract files, review and apply proposed revisions, and add new clauses.

[1775] server

[1776] The system receives and stores contract files, analyzes them using generative AI models, extracts missing keywords, generates proposed revisions, identifies special clauses, and generates and stores the final version of the contract.

[1777] Specific hardware and software to be used

[1778] Generative AI models: These use pre-trained models such as BERT and GPT.

[1779] Text processing libraries: Libraries such as PDFBox and Tika that convert PDF files into text data.

[1780] User devices: PCs, tablets, smartphones, etc.

[1781] Servers: High-performance computer servers and cloud infrastructure are utilized.

[1782] Program processing

[1783] The user selects a contract file from their device and uploads it to the server by clicking the upload button. The server saves the received contract file and converts it into text data using a text processing library (e.g., PDFBox). This text data is then input into a generative AI model (e.g., BERT) to analyze the structure and content of the contract.

[1784] Based on the analysis results, the server compares them against a list of keywords required for a standard contract and detects any missing keywords. This information is then sent to the user's terminal. The server then generates proposed revisions for any missing parts or clauses that need modification in the contract and presents these to the user.

[1785] Users can review the proposed revisions on their device and choose whether or not to apply them. The server also detects unusual or abnormal clauses within the contract and notifies the user of these as warnings.

[1786] If a user requests the addition of a new clause, they can do so through the input interface on their user terminal. Based on the request, the server generates the new clause and inserts it into the contract. Finally, the server generates and saves the final version of the contract with the modifications and additions completed. The user terminal provides the user with a download link, which the user can click to obtain the final version of the contract.

[1787] Example of a prompt

[1788] Examples of prompt messages related to contract analysis include the following:

[1789] Analyze the clause regarding "payment terms" in the contract. Check for any missing keywords and propose revisions as needed.

[1790] In this way, the present invention enables the efficient and accurate review, modification, and addition of new clauses to contracts.

[1791] ---

[1792] The flow of the specific processing in Example 1 will be explained using Figure 11.

[1793] Processing steps

[1794] Step 1:

[1795] The user selects the contract file from their device and clicks the upload button.

[1796] Specific steps: Select "Draft Contract.pdf" from the file selection screen and click the upload button. An upload request will be sent to the server.

[1797] Input: Contract file from the user's terminal.

[1798] Output: The contract file is saved on the server.

[1799] Step 2:

[1800] The server saves the received contract file and converts it into text data using a text processing library (e.g., PDFBox).

[1801] Specific action: The server converts "Draft Contract.pdf" into text data.

[1802] Input: Contract file data.

[1803] Output: Text data.

[1804] Step 3:

[1805] The server uses a generative AI model (e.g., BERT) to analyze text data. This analysis classifies the structure and content of the contract.

[1806] Specific operation: Text data is input into the AI ​​model, and outputs such as "Clause 1: Delivery date" and "Clause 2: Payment terms" are obtained.

[1807] Input: Text data.

[1808] Output: Analysis results and classification of articles.

[1809] Step 4:

[1810] The server compares the analysis results against a standard list of keywords required for contracts and extracts any missing keywords.

[1811] Specific operation: The analysis results are compared with a predefined keyword list, and any missing keywords are listed.

[1812] Input: Analysis results, standard keyword list.

[1813] Output: List of missing keywords.

[1814] Step 5:

[1815] The server analyzes the contract to identify any missing sections or clauses that need revision, and generates proposed revisions. These proposed revisions are then presented to the user's terminal.

[1816] Specific operation: Generate proposed corrections for the missing parts and send them to the user's terminal.

[1817] Input: List of missing keywords, analysis results.

[1818] Output: Revision proposal.

[1819] Step 6:

[1820] The user terminal provides an interface that allows the user to review the proposed modifications and choose whether or not to apply them.

[1821] Specific operation: The proposed fix is ​​displayed to the user, and an apply button is provided. When the user clicks the apply button, the result is sent to the server.

[1822] Input: Proposed revision.

[1823] Output: User application confirmation.

[1824] Step 7:

[1825] The server detects unusual or abnormal clauses within the contract and notifies the user's terminal.

[1826] Specific actions: Evaluate the analysis results, list any special clauses, and notify the user's terminal.

[1827] Input: Analysis results.

[1828] Output: Notification of detection of special clauses.

[1829] Step 8:

[1830] The user terminal provides an interface for adding new clauses based on the user's request and sends that request to the server. The server generates the new clauses based on the request and inserts them into the contract.

[1831] Specific operation: Based on the request entered on the user's terminal, the server generates a new clause and inserts it into the contract.

[1832] Input: User's request to add a clause.

[1833] Output: The contract with the new clause added.

[1834] Step 9:

[1835] The server generates and saves the final version of the contract. The final version of the contract is provided to the user's terminal as a download link.

[1836] Specific actions: Generate and save the completed contract in PDF format. Notify the user's terminal of the download link.

[1837] Input: Contract data with corrections and additions completed.

[1838] Output: Final version of the contract file, download link.

[1839] The above outlines the specific steps involved in the system's program processing.

[1840] (Application Example 1)

[1841] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1842] Traditional contract review systems often involved manual analysis, revision, and generation of additional clauses, resulting in inefficiency and inaccuracies. This is particularly problematic in electronic payment services, where new contracts and terms of service updates occur frequently, creating a growing demand for more efficient processes. Furthermore, there was a lack of a way to quickly present analysis results and proposed revisions to users, enabling them to take appropriate action.

[1843] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[1844] In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using a generation AI model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for reviewing and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating and inserting new clauses into the contract based on user requests, means for using a presentation device that includes presenting analysis results and proposed revisions, means for generating new clauses using a generation AI model, means for inputting user requests using prompt statements, and means for saving and providing the generated final version of the contract. This makes it possible to efficiently and accurately review, revise, and add new clauses to contracts.

[1845] A "contract file" is an electronic document file that contains the terms and conditions of a contract.

[1846] A "generative AI model" is an artificial intelligence algorithm that learns from large datasets and automatically generates new text and suggestions.

[1847] "Analysis" is the process of examining the structure and content of a contract file, and classifying and understanding the information.

[1848] A "keyword" is a specific word or phrase that holds significant meaning in a contract.

[1849] A "proposal for amendment" refers to changes proposed to improve problems within a contract.

[1850] A "presentation device" is an electronic device used to display analysis results and suggested modifications to the user.

[1851] A "prompt message" is input data used to provide a specific task or information to a generating AI model.

[1852] The "final version" refers to the completed contract after all revisions and additions have been made.

[1853] This invention provides a system for efficiently and accurately reviewing and amending contracts, and is primarily applied to electronic payment services. Specific embodiments of this system are described below.

[1854] System Overview

[1855] This system consists of a user terminal and a server that utilizes a generation AI model. The user terminal provides an interface for uploading contract files, reviewing proposed revisions, and adding new clauses, while the server analyzes the structure and content of the contract and generates and provides proposed revisions and new clauses.

[1856] Hardware and software to be used

[1857] The system uses the following hardware and software:

[1858] User devices: Smartphones, tablets, personal computers

[1859] Server: Cloud server (e.g., AWS, Google Cloud)

[1860] Generative AI model: OpenAI's GPT-3

[1861] Analysis and data processing: Python, Flask

[1862] Data storage: Database (e.g., MySQL, PostgreSQL)

[1863] System processing flow

[1864] 1. Upload the contract.

[1865] The user selects a contract file from their terminal and uploads it to the system. The uploaded contract file is sent to the server and converted into text data.

[1866] 2. Analysis of the contract

[1867] The server inputs the received contract file into an AI model that analyzes the structure and content of the contract. This analysis classifies each clause and identifies necessary keywords and items.

[1868] 3. Extraction of missing keywords

[1869] The generative AI model compares the contract to a standard keyword list and extracts any missing keywords. For example, if a "disclaimer clause" is missing, it will notify the user.

[1870] 4. Generating draft amendments to the articles

[1871] Based on the analysis results, the server generates proposed revisions for any missing sections or clauses that need correction. These proposed revisions are then presented to the user's terminal.

[1872] 5. User confirmation and application

[1873] The user reviews the proposed revisions and chooses whether to apply them. Once the revisions are applied, they are reflected in the contract text.

[1874] 6. Identification and notification of special provisions

[1875] The server detects unusual clauses or abnormal content within the contract and displays a warning to the user, thereby reducing the risk associated with the contract.

[1876] 7. Creation and insertion of new articles

[1877] If a user wants to add a new clause to a contract, they input their request as a prompt. The server uses a generative AI model to generate the appropriate clause and insert it into the contract.

[1878] 8. Generation and delivery of the final version

[1879] The server generates and saves the final version of the contract after all revisions and additions have been completed. Users can download the final version.

[1880] Examples of specific cases and prompt statements

[1881] As a concrete example of operation, a user may upload a contract and be notified that a "disclaimer clause" is missing. They can then review the proposed amendment to the disclaimer clause and choose whether to apply it. Furthermore, the process includes entering a request to add a new data protection clause, and inserting the clause generated by the AI ​​generation model into the contract.

[1882] Example of a prompt

[1883] mark down

[1884] Input contract:

[1885] ---

[1886] This agreement is entered into between our company (Party A) and the customer (Party B). It includes the following clauses:

[1887] 1. Contract period

[1888] 2. Payment Terms

[1889] ---

[1890] Missing keywords:

[1891] ---

[1892] mark down

[1893] Input request:

[1894] ---

[1895] I would like to add a new data protection clause.

[1896] ---

[1897] Generated clause:

[1898] ---

[1899] Data Protection Clause: "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy."

[1900] ---

[1901] In this way, the system provides an efficient and accurate way to review, revise, and add new clauses to contracts. This system significantly improves the efficiency and accuracy of contract operations in electronic payment services.

[1902] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[1903] Step 1:

[1904] Users select a contract file from their device, such as a smartphone or PC, and upload it to the system. Clicking the upload button sends the file to the server. The server receives the uploaded contract file and converts its contents into text data. The input is a contract file, and the output is text data.

[1905] Step 2:

[1906] The server inputs the received text data into a generating AI model, which analyzes the structure and content of the contract. The AI ​​model classifies each clause within the contract and identifies important keywords and items. The input is text data, and the output is the analysis result.

[1907] Step 3:

[1908] The server compares the analysis results against a standard list of keywords required for a contract and extracts any missing keywords. This information is then communicated to the user. The input is the analysis results, and the output is a list of missing keywords.

[1909] Step 4:

[1910] The server generates proposed revisions for missing keywords and clauses that need correction. The generated proposed revisions are presented to the user's terminal. The input is the analysis results and a list of missing keywords, and the output is the proposed revisions.

[1911] Step 5:

[1912] The user reviews the proposed revisions and chooses whether to apply them. Clicking the "Apply Revisions" button updates the contract. The input is the proposed revisions, and the output is the text data of the revised contract.

[1913] Step 6:

[1914] The server identifies unusual or abnormal clauses within the contract and notifies the user. This warning is displayed on the user's terminal. The input is the analysis result, and the output is the warning message.

[1915] Step 7:

[1916] If a user wants to add a new clause to a contract, they enter the request as a prompt. The server uses a generative AI model to generate the appropriate clause and insert it into the contract. The input is the prompt, and the output is the newly generated clause.

[1917] Step 8:

[1918] The server generates the final version of the contract after all revisions and additions have been completed and saves it to the database. Users can obtain the final version via a download link. The input is the text data of the revised contract, and the output is the final version of the contract file.

[1919] Furthermore, an emotion engine that estimates the user's emotions may be incorporated. That is, the identification processing unit 290 may use the emotion identification model 59 to estimate the user's emotions and perform identification processing using the user's emotions.

[1920] ---

[1921] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, performs AI-based analysis, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract. Furthermore, it incorporates an emotion engine that recognizes user emotions, enabling it to respond according to the user's stress and satisfaction levels. Specific embodiments of this system are described below.

[1922] Virtual system configuration

[1923] User terminal

[1924] It provides an interface that allows users to upload contract files, review and apply proposed revisions, add new clauses, and recognize emotions.

[1925] server

[1926] The system receives and saves contract files, performs AI analysis, extracts missing keywords, generates proposed revisions, identifies special clauses, generates and saves the final version of the contract, and processes emotional data using an emotional engine.

[1927] Program processing and specific examples

[1928] 1. Upload the contract.

[1929] The user terminal has the functionality to send the contract file to the server when the user selects the contract file and clicks the "Upload" button.

[1930] Example: The user selects "Draft Contract.pdf" from their device and clicks the upload button.

[1931] 2. Analysis of the contract

[1932] The server receives and saves the uploaded contract file. The saved file is converted into text data and input into the AI ​​model. The AI ​​model analyzes the structure and content of the contract and classifies each clause.

[1933] Example: The server converts "Draft Contract.pdf" into text data and categorizes it as "Clause 1: Delivery Date" and "Clause 2: Payment Terms".

[1934] 3. Extraction of missing keywords

[1935] Based on the analysis results, the server compares them against a list of keywords required for a standard contract and detects any missing keywords. This information is then notified to the user.

[1936] Example: It was discovered that the contract lacked a "disclaimer clause," and the user was notified with the message, "The disclaimer clause is missing."

[1937] 4. Generating draft amendments to the articles

[1938] The server analyzes the contract to identify any missing sections or clauses that need revision, and generates a draft revision. The generated draft revision is then presented to the user.

[1939] Example: Present the user with a proposed revision, such as "In no event shall we be liable for any indirect or consequential damages," as an example of a disclaimer.

[1940] 5. User verification

[1941] The user terminal provides an interface that allows the user to review the proposed corrections and choose whether or not to apply them.

[1942] Example: The user reviews the proposed revisions to the "Disclaimer" and clicks the Apply button.

[1943] 6. Extraction and notification of special provisions

[1944] The server detects unusual content or abnormal clauses within the contract and displays a warning to the user.

[1945] Example: A clause containing high penalties for delayed delivery was detected and notified to the user. The system warned that "this clause is not included in typical contracts."

[1946] 7. Creation and insertion of new articles

[1947] The user terminal provides the functionality to add new clauses based on user requests. The server inserts the generated clauses into the contract.

[1948] For example, if a user enters a request to "add a new data protection clause," the server will generate the following data protection clause: "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy," and insert it into the agreement.

[1949] 8. Generation and delivery of the final version

[1950] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[1951] Example: After the user has finished reviewing the final revisions, the server generates the final version of the contract. The user can then download the final version by clicking the download link.

[1952] 9. Recognition of user emotions by an emotion engine

[1953] The user terminal provides an interface for recognizing the user's emotions. The server uses an emotion engine to analyze the user's facial expressions, voice, and text input.

[1954] Example: While a user is viewing a draft contract, the system recognizes their facial expressions via camera and analyzes their voice to detect if they are experiencing stress.

[1955] 10. Emotion-based responses

[1956] Based on the analysis results from the emotion engine, the server displays a support message if the user is experiencing stress, and recommends applying the suggested fix if the user is highly satisfied.

[1957] For example, if the user is feeling stressed, a support message such as "Do you need help?" is displayed. If the user is highly satisfied, a message such as "Do you want to apply this fix?" is displayed.

[1958] This process allows the system of the present invention to not only review and revise contracts but also to respond to user emotions, thereby improving the user experience.

[1959] The following describes the processing flow.

[1960] Step 1:

[1961] The user selects the contract file from their device's browser and clicks the "Upload" button.

[1962] Specific operation: The user selects a contract file (e.g., PDF or Word file) through a file selection dialog and clicks the upload button in the browser.

[1963] Step 2:

[1964] The terminal sends the selected file to the server.

[1965] Specific operation: The device sends an HTTP request to the server via the internet and attaches the selected contract file.

[1966] Step 3:

[1967] The server receives the contract file, saves it to storage, detects the file format, and then converts it to text format.

[1968] Specific operation: The server saves the file to a specific directory and converts it into text data using OCR (Optical Character Recognition) or other file conversion tools.

[1969] Step 4:

[1970] The server inputs the converted text data into an AI model, which analyzes the structure of the contract and each clause.

[1971] Specific operation: The server supplies text data to the AI ​​model, and the model identifies and classifies each section and clause in the contract.

[1972] Step 5:

[1973] The server compares the analysis results against a list of keywords required for a standard contract and extracts any missing keywords.

[1974] Specific operation: The server compares the contract text with the keyword list and lists any missing keywords.

[1975] Step 6:

[1976] The server notifies the user of a list of missing keywords.

[1977] Specific operation: The server generates a web page to display incomplete keywords on the user interface and presents it to the user.

[1978] Step 7:

[1979] The server automatically generates proposed revisions for any missing or necessary clauses in the contract.

[1980] Specific operation: The server uses a natural language generation (NLG) algorithm to create proposed amendments while referring to standard clause templates.

[1981] Step 8:

[1982] The server presents the generated proposed fixes to the user.

[1983] Specific operation: The server displays a list of proposed fixes as a web page, allowing users to view it.

[1984] Step 9:

[1985] The user reviews the proposed changes and chooses whether to apply them.

[1986] Specific action: The user reviews the proposed changes and accepts them by clicking the apply button.

[1987] Step 10:

[1988] The server identifies any special clauses included in the contract and notifies the user.

[1989] Specific operation: The server uses an AI model to detect abnormal clauses and displays a warning message to the user.

[1990] Step 11:

[1991] The user requests the addition of a new clause.

[1992] Specific action: The user uses a browser input form to enter the content and type of the new clause.

[1993] Step 12:

[1994] The server generates new clauses based on the user's request and inserts them into the contract.

[1995] Specific operation: The server generates a new clause and inserts its content into the appropriate location.

[1996] Step 13:

[1997] The server generates and saves the final version of the contract after all modifications and additions have been completed.

[1998] Specific operation: The server saves the final text data and generates the final version of the contract file.

[1999] Step 14:

[2000] The user reviews and downloads the final version of the contract.

[2001] Specific action: The user clicks the download link for the final version of the contract and saves the file to their device.

[2002] Step 15:

[2003] The user's device provides an interface for recognizing the user's emotions. It acquires facial expressions and voice through the camera and microphone.

[2004] Specific operation: The user's device uses its camera to acquire facial expression data and its microphone to collect audio data.

[2005] Step 16:

[2006] The server uses an emotion engine to analyze the user's facial expression and voice data to determine the user's emotional state.

[2007] Specific operation: The server invokes the emotion engine, analyzes the acquired data, and determines whether the user is stressed, satisfied, etc.

[2008] Step 17:

[2009] The server determines how to respond to the user based on the results of the emotion engine. If the user is feeling stressed, a support message is displayed; if they are satisfied, it recommends that they apply the suggested fixes.

[2010] Specific operation: The server generates messages based on the user's emotional state, displaying "Do you need help?" if support is needed, and "Do you want to apply this fix?" if the user is satisfied.

[2011] This process enables the system of the present invention to efficiently and accurately review, revise, add new clauses to, and provide support that responds to the user's emotions.

[2012] (Example 2)

[2013] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[2014] Conventional contract review systems require efficiency and accuracy in analyzing contracts, proposing revisions, and identifying special clauses, which necessitates considerable time and effort. Furthermore, they lack consideration for user emotions, resulting in a poor user experience. This invention aims to solve these problems by providing a system that efficiently and accurately performs contract review and revision work while also considering user emotions.

[2015] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means.

[2016] In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using an AI model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for reviewing and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating new clauses based on user requests and inserting them into the contract, means for saving and providing the generated final version of the contract, means for analyzing the user's emotions using an emotion prediction engine to recognize the user's emotions, and means for providing appropriate responses based on the user's emotions. This makes it possible to efficiently and accurately review and revise contracts, and further improve the user experience.

[2017] A "contract file" refers to an electronic document file containing the details and clauses of a contract.

[2018] An "AI model" is an algorithm trained on machine learning and used to perform a specific task (in this case, analyzing a contract).

[2019] "Analysis results" refer to the output of data analyzed by the AI ​​model, which is information in a format that reveals the structure and content of the contract clauses.

[2020] "Missing keywords" refer to important terms or expressions that should be included in a standard contract structure but are not present in the uploaded contract data.

[2021] A "revised proposal" refers to the suggestions generated by an AI model for addressing shortcomings or improving clauses in a contract.

[2022] A "special clause" refers to a clause that is not included in a typical contract but is written to specify special conditions or provisions in a particular contract.

[2023] An "emotion prediction engine" refers to a technology used to analyze a user's facial expressions, voice, and text input to infer their emotional state.

[2024] The "final version" refers to the final, completed version of the contract after all revisions and additions have been made.

[2025] Modes for carrying out the invention

[2026] This invention provides a system for efficiently and accurately reviewing and revising contracts. The system takes in contract files, analyzes them using an AI model, extracts missing keywords, suggests proposed revisions to clauses, detects and adds special clauses, and generates and saves the final contract. Furthermore, it incorporates an emotion prediction engine to recognize user emotions, enabling it to respond according to the user's stress and satisfaction levels.

[2027] Specific system configuration

[2028] User terminal

[2029] User terminals are used to provide an interface that allows users to upload contract files, review and apply proposed revisions, add new clauses, and recognize emotions. User terminals include common computer devices such as PCs, smartphones, and tablets.

[2030] server

[2031] The server receives and stores contract files, performs AI analysis, extracts missing keywords, generates proposed revisions, identifies special clauses, generates and stores the final version of the contract, and processes sentiment data using a sentiment prediction engine. This utilizes high-performance server machines and dedicated software or cloud services.

[2032] Specifically, it uses Amazon S3 and Google Cloud Storage as storage and the Tesseract OCR engine for text conversion. It also employs generative AI models such as GPT-3 for AI analysis.

[2033] Program Processing Description

[2034] Uploading and receiving contracts

[2035] When the user selects a contract file and clicks the "Upload" button, the user terminal sends the file to the server using an HTTP POST request.

[2036] Example: When a user selects the "Draft Contract.pdf" file and clicks the upload button, the file is sent to the server.

[2037] Saving and converting contract files to text

[2038] The server temporarily stores the received contract file in storage and converts it into text data using the Tesseract OCR engine.

[2039] Example: The server saves "contract.pdf" to storage and converts it into text data using the Tesseract OCR engine.

[2040] Contract analysis and extraction of missing keywords

[2041] The server uses a generative AI model (e.g., GPT-3) to analyze the structure and content of the contract and classify each clause. The analysis results are then compared against a standard keyword list to extract any missing keywords.

[2042] Example: The analysis results yield "Clause 1: Delivery Date" and "Clause 2: Payment Terms," ​​and it is identified that the "Exemption Clause" is missing.

[2043] Generation and presentation of revised proposals

[2044] The server identifies any missing sections or clauses that need correction, generates proposed revisions using a generative AI model, and presents them to the user.

[2045] Example: One of the generated proposed revisions is, "As an example of a disclaimer, 'In no event shall we be liable for any indirect or consequential damages.'"

[2046] Detection and notification of special provisions

[2047] The server detects unusual clauses or unconventional content within the contract and displays a warning to the user.

[2048] Example: Detect a clause regarding high penalties for delayed delivery and notify the user that "this clause is not typically found in standard contracts."

[2049] Generation and insertion of new articles

[2050] The user terminal provides the functionality to add new clauses based on the user's request, and the server inserts the generated clauses into the contract.

[2051] Example: A user requests to add a data protection clause, and the server generates a clause stating, "All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy," and inserts it into the agreement.

[2052] Generation and delivery of the final version

[2053] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[2054] Example: The server generates the final version of the contract as "final_contract.pdf" and provides the user with a download link.

[2055] Emotion recognition and response using an emotion prediction engine

[2056] The user terminal uses a camera and microphone to recognize the user's emotions and sends data analyzing facial expressions and voice to the server. The server uses an emotion prediction engine to analyze the user's emotional state and provide appropriate responses.

[2057] Example: If the server detects that the user is experiencing stress through the camera and microphone, it will display a support message saying, "Do you need help?"

[2058] This process allows for efficient and accurate review and revision of contracts, while also enabling responses that take into account the user's feelings.

[2059] Example of a prompt

[2060] "Please generate the following clause to add to the contract: 'Data Protection Clause: All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy.'"

[2061] The flow of the specific processing in Example 2 will be explained using Figure 13.

[2062] Step 1: Upload the contract

[2063] The user terminal allows the user to select a contract file and click the "Upload" button. This action selects the file, and it is sent to the server as an HTTP POST request.

[2064] Input: Contract file (e.g., "Draft Contract.pdf")

[2065] Output: Contract file uploaded to the server

[2066] Specific operation: When the user selects "Draft Contract.pdf" from the file selection dialog on the device and clicks the upload button, the device sends the selected file as a POST request to the URL "https: / / example.com / upload".

[2067] Step 2: Receiving and saving the contract

[2068] The server saves the received contract file to temporary storage. The saved file will be used for future analysis.

[2069] Input: Uploaded contract file

[2070] Output: Contract file saved in storage

[2071] Specific operation: The server saves the received file as "uploads / contract.pdf" to storage.

[2072] Step 3: Convert the contract text

[2073] The server uses OCR (Optical Character Recognition) technology to convert the stored contract files into text data. Here, the Tesseract OCR engine is used.

[2074] Input: Saved contract file

[2075] Output: Contract content converted to text data

[2076] Specific operation: The server converts "contract.pdf" into text data using the Tesseract OCR engine and saves it to its internal database.

[2077] Step 4: Analysis of the contract

[2078] The server inputs text data into an AI model (e.g., GPT-3) to analyze the structure and content of the contract. The analysis results are categorized by clause.

[2079] Input: Contract content converted to text data

[2080] Output: Structured analysis results (e.g., "Clause 1: Delivery Date", "Clause 2: Payment Terms", etc.)

[2081] Specific operation: The server inputs text data into an AI model and obtains results from analyzing and classifying each clause of the contract.

[2082] Step 5: Extracting missing keywords

[2083] The server compares the analysis results with a list of keywords required for a standard contract and detects any missing keywords.

[2084] Input: Structured analysis results, standard keyword list

[2085] Output: List of missing keywords

[2086] Specific operation: The server compares the analysis results with the list in the "standard_keywords.xlsx" file and finds that the "Disclaimer" is missing.

[2087] Step 6: Notification of missing keywords

[2088] The server notifies the user of information regarding missing keywords. This information is sent via API response or WebSocket.

[2089] Input: List of missing keywords

[2090] Output: Notification message to the user

[2091] Specific action: The server sends a notification to the user's terminal via WebSocket stating, "Disclaimer clause is missing."

[2092] Step 7: Generating proposed amendments to the articles

[2093] The server identifies incomplete or missing clauses and generates proposed revisions using a generative AI model (e.g., GPT-3).

[2094] Input: Missing keywords or incomplete clauses

[2095] Output: Generated proposed revisions

[2096] Specific operation: Use a generative AI model to generate the following as an example of a disclaimer: "In no event shall we be liable for any indirect or consequential damages."

[2097] Step 8: Present the revised proposal

[2098] The user terminal presents the generated proposed fixes to the user and provides an interface for review and application. The user can review them and choose whether or not to apply them.

[2099] Input: Generated proposed revisions

[2100] Output: User confirmation and application instructions

[2101] Specific action: The user terminal displays a dialog box asking, "Do you want to apply the proposed amendments to the disclaimer?" and receives the user's selection.

[2102] Step 9: Detection and notification of special provisions

[2103] The server detects unusual clauses or unconventional content within the contract and displays a warning to the user.

[2104] Input: Structured analysis results

[2105] Output: Notification of unusual clauses or unusual content

[2106] Specific action: Detects "high penalty clauses for delayed delivery" and notifies the user that "this clause is not included in typical contracts."

[2107] Step 10: Generating and inserting new clauses

[2108] The user terminal provides the functionality to add new clauses based on the user's request, and the server inserts the generated clauses into the contract.

[2109] Input: User request, generated AI model

[2110] Output: New clauses added to the contract

[2111] Specific operation: The user requests to "add a data protection clause," and the server generates a clause stating, "'All personal information collected under this agreement will be handled appropriately in accordance with our privacy policy.'" and inserts it into the agreement.

[2112] Step 11: Generating and delivering the final version

[2113] The server generates the final version of the contract, after all revisions and additions have been completed, and saves it to storage. The user terminal provides the user with a download link for the final version.

[2114] Input: Completed contract with revisions and additions.

[2115] Output: Final version of the contract, download link

[2116] Specific operation: The server generates the final version of the contract in PDF format, saves it to storage as "final_contract.pdf", and provides the user with a download link.

[2117] Step 12: Emotion Recognition by Emotion Prediction Engine

[2118] The user terminal uses a camera and microphone to recognize the user's emotions, recording their facial expressions and voice and sending them to the server. The server uses an emotion prediction engine to analyze the user's emotional state.

[2119] Input: User facial expression data, voice data

[2120] Output: Analysis results of the user's emotional state

[2121] Specific operation: The user's device uses its camera and microphone to record the user's facial expressions and voice in real time and send them to the server. The server analyzes this data to determine whether the user is experiencing stress.

[2122] Step 13: Emotion-Based Responses

[2123] Based on the analysis results of the emotion prediction engine, the server displays a support message if the user is experiencing stress, and recommends applying the suggested fix if the user is highly satisfied.

[2124] Input: Analysis results of emotional state

[2125] Output: Support message or recommendation to apply a fix to the user.

[2126] Specific actions: If the user is feeling stressed, the message "Do you need help?" will be displayed; if the user is highly satisfied, the message "Do you want to apply this fix?" will be displayed.

[2127] These steps enable the system to efficiently and accurately review and revise contracts, while also providing a user-friendly operating environment that is sensitive to user emotions.

[2128] (Application Example 2)

[2129] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[2130] While systems exist that efficiently and accurately review and revise contracts, very few systems have the functionality to respond based on the user's emotions and stress levels. Furthermore, in today's mobile society, systems that allow contract review and revision in specific environments, such as autonomous vehicles, are limited, and there is a need to improve the user experience. Therefore, there is a need to provide a system that allows users to efficiently review and revise contracts even while on the go, and that can also provide support based on the user's emotions.

[2131] In Application Example 2, the identification processing by the identification processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for uploading a contract file, means for analyzing the structure and content of the contract using an artificial intelligence model, means for extracting missing keywords based on the analysis results, means for generating proposed revisions to modify clauses within the contract, means for confirming and applying the proposed revisions presented to the user, means for identifying and notifying special clauses within the contract, means for generating new clauses based on the user's request and inserting them into the contract, means for saving and providing the generated final version of the contract, means for acquiring the user's image data and voice data, and means for recognizing the user's emotions from the acquired data and responding accordingly. This enables the user to efficiently review and revise contracts even in an autonomous vehicle, and further enables the provision of appropriate support based on the user's emotions.

[2132] A "contract file" is a document file that contains the details of a contract.

[2133] An "artificial intelligence model" refers to a program or algorithm designed to mimic human intelligent behavior.

[2134] "The structure of a contract" refers to the arrangement and organizational structure of chapters and clauses within the contract.

[2135] "Missing keywords" are important words or phrases that are necessary for a standard contract but are missing from current contracts.

[2136] A "proposal for amendment" is a draft or suggestion for improving or modifying the clauses or content within a contract.

[2137] A "special clause" is a clause that specifies particular conditions or provisions that are not included in a typical contract.

[2138] "Image data" refers to photographic and video information acquired by devices such as cameras.

[2139] "Audio data" refers to audio information acquired by devices such as microphones.

[2140] "Emotions" refer to a person's psychological state, and include, for example, joy, sadness, anger, and surprise.

[2141] A "server" is a computer system used for data processing and storage.

[2142] This invention is a system for enabling users to efficiently and accurately review and modify contracts within an autonomous vehicle. Specific embodiments of this system are described below.

[2143] System Configuration

[2144] User terminal:

[2145] This is an in-vehicle interface that allows for uploading contract files, reviewing and applying proposed revisions, adding new clauses, and recognizing emotions.

[2146] server:

[2147] The process involves receiving and saving contract files, analyzing them using artificial intelligence models, extracting missing keywords, generating proposed revisions, identifying special clauses, generating and saving the final version of the contract, and processing sentiment data using a sentiment engine.

[2148] Processing Overview

[2149] 1. Upload the contract.

[2150] The user selects the contract file from a user device such as a tablet or smartphone inside the vehicle and clicks the "Upload" button. This sends the contract file to the server.

[2151] 2. Analysis of the contract

[2152] The server receives and stores the uploaded contract file and converts it into text data. The converted data is then input into an artificial intelligence model to analyze the structure and content of the contract.

[2153] 3. Extraction of missing keywords

[2154] The server compares the analysis results against a list of keywords required for the contract and detects any missing keywords. This result is notified to the user in real time.

[2155] 4. Generating draft amendments to the articles

[2156] The server identifies any deficiencies or inappropriate parts and generates suggested fixes based on those findings. These suggested fixes are then presented to the user through the interface.

[2157] 5. User verification

[2158] The user terminal provides an interface that allows the user to review the proposed corrections and decide whether or not to apply the corrections on the spot.

[2159] 6. Identification and notification of special provisions

[2160] The server detects special clauses within the contract and displays them to the user as warnings or notifications.

[2161] 7. Creation and insertion of new articles

[2162] The user terminal provides the functionality to add new clauses based on user requests. The server inserts the generated clauses into the contract.

[2163] 8. Generation and delivery of the final version

[2164] The server generates and saves the final version of the contract after all modifications and additions have been completed. The user terminal provides the user with a download link.

[2165] 9. Recognition of user emotions by an emotion engine

[2166] The user terminal collects the user's facial expressions and voice through its camera and microphone. The server recognizes the user's emotions from the acquired data and takes appropriate action based on those emotions.

[2167] 10. Emotion-based responses

[2168] If the user is experiencing stress, the server will display a message asking, "Do you need help?" If the user is highly satisfied, it will recommend applying the suggested fix.

[2169] Hardware and software to use

[2170] Hardware: Cameras, microphones, tablets, smartphones, etc.

[2171] Software: OpenCV (image processing), Keras (deep learning models), Transformers (BERT model), emotion engine.

[2172] Specific example

[2173] Example 1: A user uploads a contract document within the vehicle, and the system automatically suggests any missing items or proposed revisions.

[2174] Example 2: If a user feels stressed while viewing a contract in the vehicle, the camera captures their facial expression and displays the message, "Do you need assistance?"

[2175] Example of a prompt 【2176...

Claims

1. Methods for uploading contract files, A method for analyzing the structure and content of a contract using an AI model, A method for extracting missing keywords based on the analysis results, A means of generating proposed amendments to modify clauses within a contract, A means for reviewing and applying the proposed modifications presented to the user, Means of identifying and notifying special clauses within a contract, A means of generating new clauses based on user requests and inserting them into the contract, A system that includes means for storing and providing the final version of the generated contract.

2. The system according to claim 1, wherein an AI model analyzes a contract using a pre-trained dataset.

3. The system according to claim 1, which uses an input form when a user requests a new clause in a contract and generates a clause based on the contents of that form.

Images