system

Abstract

We provide the system. [Solution] A means of collecting data from past databases, A means for cleansing and imputing missing values ​​in the collected data, Means for extracting and encoding features related to litigation, Means for building and training machine learning models, A means of predicting the probability of winning a case based on a trained model, A system that includes means for presenting prediction results and proposed countermeasures.

Description

Technical Field

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

Background Art

[0002] Patent Document 1 discloses a method for controlling a persona chatbot, which is performed by at least one processor, and includes steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to an explanation of a character of the chatbot, 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] In a conventional litigation consideration system, data collection and processing from a past database are often performed manually, which takes time and effort. Also, since the prediction of winning a lawsuit is subjective, it has been difficult to make a prediction based on objective data. Furthermore, there is also a lack of a system for presenting an optimal countermeasure plan, and sufficient support for a user to make appropriate litigation preparations has not been provided.

Means for Solving the Problems

[0005] The present invention solves the problems of the past by providing a system that includes means for collecting data from past databases, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to litigation, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, and means for presenting the prediction results and proposed countermeasures to the user.

[0006] Specifically, based on the litigation information entered by the user, the server collects relevant data from past databases and automatically performs data cleansing and missing value imputation. Furthermore, it extracts important features related to the litigation and trains a model using a machine learning algorithm. Using this trained model, the server predicts the probability of winning the case for the user and proposes specific countermeasures based on the results. In this way, the user can make appropriate litigation preparations using objective, data-driven information.

[0007] A "database" is a system that systematically stores and manages data such as past litigation information, legal documents, and precedents.

[0008] "Data cleansing" is the process of detecting, correcting, or removing inaccurate, incomplete, or duplicate data from a dataset.

[0009] "Missing value imputation" is the process of using statistical methods and algorithms to fill in missing data within a dataset.

[0010] "Feature extraction" is the process of automatically extracting important features from data for use in machine learning models.

[0011] "Encoding" is the process of converting categorical data into numerical data.

[0012] A "machine learning model" is an algorithm that learns patterns based on training data and makes predictions about unknown data.

[0013] Cross-validation is a technique that divides a dataset into multiple parts and uses different parts as training and test data to evaluate the generalization performance of a model.

[0014] "Predicting the probability of winning a lawsuit" refers to predicting the probability of winning a lawsuit using statistical methods or machine learning models.

[0015] "Presenting countermeasures" means providing users with a concrete action plan to increase their chances of winning the case.

[0016] A "user" is an individual or organization that uses this system to consider and prepare for litigation.

[0017] A "server" is a hardware and software system that provides computing resources for performing tasks such as data collection, processing, and predictive calculations. [Brief explanation of the drawing]

[0018] [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]It 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] It shows an emotion map to which a plurality of emotions are mapped. [Figure 10] It 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 Example 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 Example 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.

Modes for Carrying Out the Invention

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

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

[0021] In the following embodiments, the numbered processor (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.

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

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

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

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

[0026] [First Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0039] System Configuration

[0040] This invention is a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation, and consists of a server, a user terminal, and a database. The user terminal provides an interface for inputting litigation information, and the server performs data collection, preprocessing, feature extraction, model training, prediction, and result presentation.

[0041] System program processing

[0042] 1. Data Collection

[0043] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) via their device.

[0044] The server receives this input information and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[0045] 2. Data preprocessing

[0046] The server cleanses the collected data, removing inaccurate and duplicate data.

[0047] The server identifies data with missing values ​​and imputes them. For example, it might use statistical methods to impute them with the mean, or predict them based on past trends.

[0048] The server converts the data into a format that is easy for machine learning algorithms to process, and converts text data into numerical data.

[0049] 3. Feature Extraction

[0050] The server selects features from past litigation data that may influence the outcome of a lawsuit. Specific examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[0051] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[0052] 4. Model Learning

[0053] The server splits the dataset into training data and test data, and then builds a model based on the training data using the selected machine learning model.

[0054] The server performs cross-validation and evaluates the accuracy of the model.

[0055] 5. Prediction and Analysis

[0056] When a user enters new litigation information, the server uses a pre-trained model to predict the probability of winning the case based on that information.

[0057] Along with the predicted probability of winning the case, the server presents the user with specific countermeasures. For example, it might suggest concrete action plans such as "review the contract clauses" or "submit additional supporting documents."

[0058] Specific example

[0059] 1. Specific examples of data collection

[0060] For example, if a user is considering a "breach of contract lawsuit," they would enter the judge's name and information about past cases. The server would then retrieve similar lawsuit data from the past 10 years and the latest legal amendments from its database.

[0061] 2. Specific Examples of Data Preprocessing

[0062] The server preprocesses the retrieved data; for example, if there are missing values, it uses the average of similar historical data to fill them in. For non-numeric data, it converts the text to numbers.

[0063] 3. Specific Examples of Feature Extraction

[0064] If the type of lawsuit is "breach of contract," the server extracts features from past court data that influence the outcome of similar lawsuits (e.g., the content of the contract and the presence or absence of evidence).

[0065] 4. Specific Examples of Model Learning

[0066] The server builds a machine learning model using contract breach litigation data and evaluates its accuracy using cross-validation.

[0067] 5. Specific examples of predictions and proposed countermeasures

[0068] When a user provides new litigation information, the server predicts a "75% chance of winning" and suggests specific countermeasures such as "revising the contract clauses and submitting additional evidence."

[0069] This system assists decision-making when considering litigation and provides support to help users proceed with litigation from a more advantageous position.

[0070] The following describes the processing flow.

[0071] Step 1:

[0072] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) via their device.

[0073] Step 2:

[0074] The server receives user input information and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[0075] Step 3:

[0076] The server cleanses the collected data, removing inaccurate and duplicate data.

[0077] Step 4:

[0078] The server identifies data with missing values ​​and imputes them using statistical methods. For example, it might use the mean to impute them.

[0079] Step 5:

[0080] The server converts the data into a format that machine learning algorithms can easily process. Specifically, it converts text data into numerical data.

[0081] Step 6:

[0082] The server selects features from past litigation data that may influence the outcome of a lawsuit. Examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[0083] Step 7:

[0084] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[0085] Step 8:

[0086] The server splits the dataset into training and test data. This makes it easier to evaluate the generalization performance of the model.

[0087] Step 9:

[0088] The server uses the selected machine learning model to build a model based on the training data.

[0089] Step 10:

[0090] The server performs cross-validation and evaluates the accuracy of the model.

[0091] Step 11:

[0092] When a user enters new litigation information, the server uses a pre-trained model to predict the probability of winning the case based on that information.

[0093] Step 12:

[0094] The server presents the user with a predicted probability of winning the case, along with specific countermeasures. For example, it might suggest concrete action plans such as "review the contract clauses" or "submit additional supporting documents."

[0095] (Example 1)

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

[0097] Conventional litigation support systems struggle to provide reliable data analysis and concrete strategies for users to predict the probability of winning a lawsuit. In particular, traditional methods are inefficient at processing inaccurate and duplicate data, imputing missing data, extracting and encoding features, and evaluating the accuracy of machine learning models, resulting in insufficient support for user decision-making.

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

[0099] In this invention, the server includes means for dynamically collecting information from a past database based on litigation information entered by the user; means for cleansing the collected information, removing inaccurate and duplicate data, and supplementing missing data; means for selecting features that affect the outcome of the litigation and encoding categorical data into numerical data; means for building a model based on training data using a machine learning model and evaluating the accuracy of the model by cross-validation; means for predicting the probability of winning from newly entered litigation information based on the trained model; and means for presenting specific countermeasures along with the prediction results. This makes it possible to predict the probability of winning with high accuracy and to present specific and effective litigation countermeasures.

[0100] A "user" is an individual or organization that uses the system to input litigation information and receives predictions of the probability of winning and suggestions for countermeasures.

[0101] "Terminal" refers to a device used by a user to input litigation information, and includes personal computers, smartphones, tablets, etc.

[0102] A "server" is a central processing unit that processes information entered by users and performs data collection, data preprocessing, feature extraction, model training, prediction, and result presentation.

[0103] A "database" is an information storage system used to manage and retrieve past litigation data and the latest legal information.

[0104] "Data cleansing" is the process of removing inaccurate or duplicate data from collected information to improve data consistency and reliability.

[0105] "Missing data imputation" is the process of filling in missing values ​​in a dataset using statistical methods or other data points.

[0106] "Feature extraction" is a process used to identify important data items that may influence the outcome of a lawsuit and to analyze litigation information.

[0107] "Category data encoding" is the process of converting text or categorical data into numerical data that can be processed by machine learning.

[0108] A "machine learning model" is an algorithm that is trained using historical data and then used to make predictions and classifications on new data.

[0109] Cross-validation is a technique for evaluating the generality and accuracy of a model by dividing the training data and performing multiple training and evaluation iterations.

[0110] "Predicting the probability of winning a case" is the process of using a pre-trained model to numerically calculate the likelihood of winning a case based on new litigation information.

[0111] "Presenting countermeasures" is the process of proposing specific actions and strategies that users should take based on the predicted probability of winning the case.

[0112] The following describes in detail the embodiments for which this invention is specifically implemented.

[0113] System Configuration

[0114] This invention is a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation, and consists of a server, a user terminal, and a database. The user terminal provides an interface for inputting litigation information, and the server performs data collection, preprocessing, feature extraction, model training, prediction, and result presentation.

[0115] Hardware and software to be used

[0116] 1. Hardware

[0117] User terminal: A device such as a personal computer, smartphone, or tablet.

[0118] Server: A central processing unit for data processing. A server equipped with a high-performance processor.

[0119] Database: A storage system for managing litigation data. Specifically, MySQL (registered trademark) will be used.

[0120] 2. Software

[0121] Data cleansing and imputation: Using the Python Pandas library.

[0122] Feature extraction and encoding: Use CountVectorizer and One-Hot encoding from the Scikit-learn library.

[0123] Model training and accuracy evaluation: Use RandomForestClassifier and cross-validation from the Scikit-learn library.

[0124] Program processing

[0125] 1. Data Collection

[0126] The user enters litigation information through their device. This information includes the type of lawsuit, the judge's information, and relevant legal documents.

[0127] The server receives input information in real time and collects historical litigation data and the latest legal information. Specifically, it uses the Flask framework in Python to receive data and retrieves relevant information from a MySQL database.

[0128] 2. Data preprocessing

[0129] The server cleanses the collected data, removing inaccurate and duplicate entries. This is done using the Python Pandas library.

[0130] The server will impute missing data. Missing values ​​will be filled in using statistical methods, specifically by calculating the mean using the Pandas library.

[0131] The server converts the data format into one that is easily processed by machine learning algorithms. Text data is converted to numerical data using CountVectorizer.

[0132] 3. Feature Extraction

[0133] The server extracts features that influence the outcome of the lawsuit. This process uses the Scikit-learn library to select features such as the type of lawsuit, the judge's ruling tendencies, and the lawyer's experience.

[0134] The server encodes categorical data into numerical data. One-hot encoding is used to convert categorical data into numerical data.

[0135] 4. Model Learning

[0136] The server splits the dataset into training and test data and builds a model using the RandomForestClassifier from the Scikit-learn library.

[0137] The server performs cross-validation to evaluate the model's accuracy. This verifies the model's generality and accuracy.

[0138] 5. Prediction and Analysis

[0139] When a user enters new litigation information, the server uses a pre-trained model to predict the probability of winning the case.

[0140] Based on the prediction results, the server presents the user with specific countermeasures. For example, in the case of a breach of contract lawsuit, it might display a "75% chance of winning" and suggest "revise the contract clauses and submit additional supporting documents."

[0141] Specific example

[0142] 1. Example of data collection

[0143] The user considers filing a "breach of contract lawsuit" and enters the judge's name and details of the lawsuit into their terminal. The server receives this information and collects similar lawsuit data from its MySQL database.

[0144] 2. Examples of data preprocessing

[0145] The server cleanses the collected data using the Pandas library and imputes missing data. For example, it might use the mean of similar historical data to impute missing values.

[0146] 3. Examples of Feature Extraction

[0147] If the type of lawsuit is "breach of contract," the server extracts features such as the content of the contract and the presence or absence of evidence from past court data.

[0148] 4. Examples of Model Learning

[0149] The server uses contract breach litigation data to build a machine learning model with RandomForestClassifier and performs cross-validation.

[0150] 5. Examples of Predictions and Proposed Countermeasures

[0151] When a user enters new litigation information, the server predicts a "75% chance of winning" and suggests specific countermeasures such as "re-examining the contract clauses" or "submitting additional evidence."

[0152] Example of a prompt

[0153] "We are considering filing a lawsuit for breach of contract. Based on past data from similar lawsuits and the latest legal information, please predict the probability of winning and propose specific countermeasures."

[0154] This system will enable effective support for users' decision-making when considering litigation.

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

[0156] Step 1:

[0157] The user enters litigation information via their device. This input includes the type of litigation, judge information, and relevant legal documents. For example, if the user is considering a "breach of contract lawsuit," they would enter the judge's name and details of the lawsuit. Input: Litigation information (e.g., type of litigation, judge's name, relevant legal documents). Output: Litigation information sent to the endpoint.

[0158] Step 2:

[0159] The server receives litigation information submitted by users in real time. Based on the received information, it executes queries to collect relevant information from historical litigation databases and current legal databases. Specifically, it uses the Flask framework in Python to receive data and retrieve the necessary information from a MySQL database. Input: Litigation information submitted to the endpoint. Output: Historical litigation data and current legal information.

[0160] Step 3:

[0161] The server cleanses the collected data. Specifically, it uses the Pandas library to remove inaccurate and duplicate data. Next, it imputes missing data and converts text data to numerical data. The mean of similar historical data is used to impute missing values. For example, the mean of similar historical litigation data is used to impute missing values. Input: Historical litigation data and recent legal information. Output: Preprocessed dataset.

[0162] Step 4:

[0163] The server extracts features from a preprocessed dataset and encodes categorical data into numerical data. The Scikit-learn library is used for feature extraction, selecting important features (e.g., type of lawsuit, judge's ruling tendencies, lawyer's experience). Categorical data is converted to numerical data using one-hot encoding. Input: Preprocessed dataset. Output: Feature-extracted and encoded dataset.

[0164] Step 5:

[0165] The server trains a machine learning model using a feature-extracted dataset. It splits the dataset into training and test data, and builds and trains the model using the RandomForestClassifier from the Scikit-learn library. The model's accuracy is evaluated using cross-validation. Input: Feature-extracted and encoded dataset. Output: Trained machine learning model and its evaluation results.

[0166] Step 6:

[0167] When a user enters new litigation information, the server predicts the probability of winning based on a trained model. The entered litigation information is fed into the model, and the prediction result is calculated. For example, when new litigation information is entered, "75% probability of winning" is displayed. Input: New litigation information. Output: Predicted probability of winning result.

[0168] Step 7:

[0169] The server presents the user with specific countermeasures based on the prediction results. For example, it might suggest concrete action plans such as "revise the contract clauses and submit additional supporting documents." This allows the user to proceed with the lawsuit from a more advantageous position. Input: Predicted probability of winning. Output: Specific countermeasures.

[0170] Through the processing steps described above, this system provides users with the necessary information analysis and countermeasures when proceeding with litigation, thereby supporting their decision-making.

[0171] (Application Example 1)

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

[0173] Conventional litigation support systems have suffered from insufficient prediction and countermeasures based on past precedents and legal amendments. As a result, users have difficulty making decisions when considering litigation, and risk management is not adequately implemented. Furthermore, there was no means to dynamically analyze the information users entered regarding legal issues and appropriately present specific countermeasures, thus requiring a swift and accurate response.

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

[0175] In this invention, the server includes means for collecting data from a historical database, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to the lawsuit, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, means for receiving input of legal issues from users, visualizing and displaying the results, and means for dynamically generating and presenting specific countermeasures. This enables dynamic analysis when a user inputs a legal issue, allowing for appropriate prediction of the probability of winning and presentation of specific countermeasures.

[0176] A "historical database" is a data storage system that preserves past precedents and legal document information related to litigation.

[0177] "Means of data collection" refers to techniques or methods for extracting necessary data from specific sources and storing it in a database.

[0178] "Data cleansing techniques" are techniques or methods for removing inaccurate or duplicate data in order to improve data quality.

[0179] "Missing value imputation" is the process of appropriately filling in missing data present in a portion of a dataset using statistical methods or inference.

[0180] "Means for extracting features relevant to litigation" refers to techniques or methods for selecting important attributes or elements that influence the outcome of litigation.

[0181] "Encoding means" refers to techniques or methods that convert categorical data into numerical data that can be processed by machine learning algorithms.

[0182] A "machine learning model" is a mathematical algorithm or statistical model that learns patterns and trends based on training data to perform predictions and classifications.

[0183] "Means of building and training" refers to techniques or methods for creating a model using training data and then optimizing its performance.

[0184] "Methods for predicting the probability of winning a case" refer to techniques or methods for probabilistically evaluating the outcome of a lawsuit based on a model.

[0185] "Means of receiving input on legal issues" refers to a technology or method for incorporating legal information provided by users into a system through an interface.

[0186] "Means of visualizing and displaying results" refers to techniques or methods for presenting data or prediction results to users in a visual format such as graphs or charts.

[0187] "Means for dynamically generating and presenting specific countermeasures" refers to a technology or method that generates and proposes actionable countermeasures in real time based on user input information.

[0188] This invention relates to a "corporate compliance monitoring application" that enables companies to anticipate legal issues in advance and take concrete countermeasures. This system consists of a server, user terminals, and a database.

[0189] System Configuration

[0190] The server uses hardware and software to perform the following functions:

[0191] For data collection and cleansing, we use database management systems (MySQL, PostgreSQL) and data analysis libraries (Pandas).

[0192] Feature extraction and encoding will be performed using the machine learning library (Scikit-learn).

[0193] Random Forest is used to build and train machine learning models.

[0194] The user terminal provides an interface for legal personnel to input information on legal issues and visually displays predicted results and proposed solutions from the server. A web browser or mobile application is used for the graphical user interface (GUI).

[0195] The database stores past case precedents and information on legal amendments, and is used by the server to dynamically search and extract the necessary data.

[0196] System processing

[0197] 1. Data collection:

[0198] The server receives information about legal issues sent from user terminals and collects relevant past case data and the latest legal amendment information from its database.

[0199] 2. Data preprocessing:

[0200] The server cleanses the collected data, removing inaccurate and duplicate data. Furthermore, it imputes missing values ​​and encodes categorical data into numerical data.

[0201] 3. Feature extraction and model training:

[0202] The server extracts features relevant to the lawsuit and builds a machine learning model based on historical data. The model's accuracy is evaluated using cross-validation.

[0203] 4. Predictions and proposed countermeasures:

[0204] When a new legal issue is entered by a user, the server predicts the probability of winning the case based on its model and dynamically generates and presents specific countermeasures. The prediction results and countermeasures are displayed visually on the user's terminal.

[0205] Program Processing Description

[0206] The server first receives information about legal issues and collects relevant data from historical databases. During the data collection process, a database management system (MySQL, PostgreSQL) is used to search for and extract the necessary data. Subsequently, the Pandas data analysis library is used to cleanse the data and impute missing values.

[0207] Next, the server extracts features related to the lawsuit from the collected data and encodes them into numerical data. Scikit-learn is used for this process. The Random Forest algorithm is employed for model construction and training, and the model's accuracy is evaluated by performing cross-validation.

[0208] When a user enters a new legal issue, the server predicts the probability of winning based on a trained model and displays this visually on the user's terminal. In addition, it dynamically generates proposed solutions and presents the user with a concrete action plan. This allows the user to take quick and appropriate action.

[0209] Specific example

[0210] For example, if a user is considering a "breach of contract lawsuit," they enter the judge's name and information about past cases. The server then retrieves data on similar lawsuits from the past 10 years and the latest legal amendments from its database and processes it. As a result, it displays a "75% chance of winning" and suggests countermeasures such as "reviewing the contract clauses and submitting additional evidence."

[0211] An example of a prompt message for a generative AI model is: "Build a model to predict the probability of winning a current legal issue based on past case data collected by a compliance monitoring application. Use features such as the type of legal issue, judge information, and legal documents to predict the probability of winning and create a prompt message that suggests specific countermeasures."

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

[0213] Step 1:

[0214] Data collection

[0215] The server receives information about the legal issue entered by the user (e.g., type of lawsuit, judge information, relevant documents). Based on this input, the server collects relevant case law data and the latest legal amendment information from its historical database.

[0216] Input: Information on legal issues

[0217] Output: Collected historical case law data and information on legal amendments.

[0218] Specifically, the server uses a database management system (MySQL, PostgreSQL) to query and retrieve the relevant data. For example, it might collect data on contract breaches over the past 10 years or information on the latest legal changes.

[0219] Step 2:

[0220] Data preprocessing

[0221] The server cleanses the collected data, removing inaccurate and duplicate data. If the collected data contains missing values, statistical methods are used to impute them.

[0222] Input: Collected historical case law data and information on legal amendments.

[0223] Output: Cleansed and imputed data

[0224] Specifically, the data is preprocessed using the Pandas data analysis library. Inaccurate and duplicate data are removed, and missing values ​​are imputed by predicting them from the mean or historical trends.

[0225] Step 3:

[0226] Feature extraction and encoding

[0227] The server extracts features from the cleansed data that could potentially influence the outcome of the lawsuit and encodes categorical data into numerical data.

[0228] Input: Cleansed data

[0229] Output: Data with extracted and encoded features

[0230] Specifically, the Scikit-learn library is used to quantify features such as the type of lawsuit, the judge's tendencies, and the content of legal documents. Categorical data is converted to numerical values ​​using LabelEncoder.

[0231] Step 4:

[0232] Model Learning

[0233] The server builds a machine learning model based on the data from which features have been extracted and encoded, and then trains it using the training data. After training, cross-validation is performed to evaluate the accuracy of the model.

[0234] Input: Data from which features have been extracted and encoded.

[0235] Output: Trained machine learning model

[0236] The server builds a model using the RandomForest algorithm from the Scikit-learn library, splits the data into training and test sets, and trains the model. Cross-validation is used to evaluate the model's accuracy and select the optimal model.

[0237] Step 5:

[0238] Predictions and proposed countermeasures

[0239] When a user inputs information about a new legal issue, the server predicts the probability of winning based on a trained model. It visualizes the prediction and displays it on the user's terminal, dynamically generating and proposing specific countermeasures.

[0240] Input: Information on new legal issues

[0241] Output: Predicted probability of winning the case and specific countermeasures.

[0242] Specifically, the server inputs data on new legal issues into a pre-trained model and obtains a predicted probability of winning. It then uses visualization tools to display the results in graphs and charts and presents specific countermeasures (e.g., reviewing contract clauses and submitting additional evidence).

[0243] Examples of prompts for a generative AI model:

[0244] "Based on past case data collected by a compliance monitoring application, we will build a model to predict the probability of winning current legal issues. Using features such as the type of legal issue, judge information, and legal documents, we will predict the probability of winning and create prompt messages suggesting specific countermeasures."

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

[0246] System Configuration

[0247] This invention relates to a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation, and consists of a server, a user terminal, a database, and an emotion engine. The user terminal provides an interface for inputting litigation information and the user's emotions, the server collects data, preprocesses it, extracts features, trains the model, makes predictions, and presents results, and the emotion engine recognizes the user's emotions and improves the system's performance.

[0248] System program processing

[0249] 1. Data Collection

[0250] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information via their device.

[0251] The server receives this input information and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[0252] 2. Data preprocessing

[0253] The server cleanses the collected data, removing inaccurate and duplicate data.

[0254] The server identifies data with missing values ​​and imputes them. For example, it might use statistical methods to impute them with the mean.

[0255] The server converts the data into a format that is easy for machine learning algorithms to process, and converts text data into numerical data.

[0256] 3. Feature Extraction

[0257] The server selects features from past litigation data that may influence the outcome of a lawsuit. Specific examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[0258] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[0259] 4. Model Learning

[0260] The server splits the dataset into training data and test data, and then builds a model based on the training data using the selected machine learning model.

[0261] The server performs cross-validation and evaluates the accuracy of the model.

[0262] 5. Emotion recognition

[0263] The emotion engine receives emotional information entered by the user and recognizes those emotions.

[0264] The server dynamically adjusts prediction results and suggested countermeasures based on user emotion information obtained from the emotion engine.

[0265] 6. Prediction and Analysis

[0266] When a user inputs new litigation information and sentiment information, the server uses that information to predict the probability of winning the case using a pre-trained model.

[0267] Along with the predicted probability of winning, the server uses information from the emotion engine to suggest the most suitable course of action to the user. For example, it might suggest specific action plans such as "review the contract clauses" or "submit additional supporting documents."

[0268] Specific example

[0269] 1. Specific examples of data collection

[0270] For example, if a user is considering a "breach of contract lawsuit," they would enter the judge's name and information about past cases. The server would then retrieve similar lawsuit data from the past 10 years and the latest legal amendments from its database.

[0271] 2. Specific Examples of Data Preprocessing

[0272] The server preprocesses the retrieved data; for example, if there are missing values, it uses the average of similar historical data to fill them in. For non-numeric data, it converts the text to numbers.

[0273] 3. Specific Examples of Feature Extraction

[0274] If the type of lawsuit is "breach of contract," the server extracts features from past court data that influence the outcome of similar lawsuits (e.g., the content of the contract and the presence or absence of evidence).

[0275] 4. Specific Examples of Model Learning

[0276] The server builds a machine learning model using contract breach litigation data and evaluates its accuracy using cross-validation.

[0277] 5. Specific examples of emotion recognition

[0278] When a user inputs emotional information into the device, the emotion engine analyzes that information and recognizes emotional states such as "high stress" or "feeling at ease."

[0279] 6. Specific Examples of Prediction and Countermeasure Proposals

[0280] When the user provides new litigation information and emotional information, the server predicts "a 75% probability of winning" based on the data from the emotion engine. For example, if the user is feeling stressed, it proposes "consult with a lawyer in a relaxing environment" and "review the terms of the contract and submit additional evidentiary documents".

[0281] This system not only supports decision-making during litigation consideration but also supports more appropriate and effective litigation preparation by providing countermeasure proposals that take into account the user's emotional state.

[0282] The following describes the processing flow.

[0283] Step 1:

[0284] The user inputs the current litigation information (type of litigation, judge information, related legal documents, etc.) and emotional information through the terminal.

[0285] Step 2:

[0286] The server receives the input information from the user and collects related data from the past litigation database. It also collects legal amendment information and the latest case laws from the latest legal database.

[0287] Step 3:

[0288] The server cleans the collected data and removes inaccurate and duplicate data.

[0289] Step 4:

[0290] The server identifies data with missing values and complements the missing values with the average value using statistical methods.

[0291] Step 5:

[0292] The server converts the data into a format that machine learning algorithms can easily process. Specifically, it converts text data into numerical data.

[0293] Step 6:

[0294] The server selects features from past litigation data that may influence the outcome of a lawsuit. Examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[0295] Step 7:

[0296] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[0297] Step 8:

[0298] The server splits the dataset into training and test data. This makes it easier to evaluate the generalization performance of the model.

[0299] Step 9:

[0300] The server uses the selected machine learning model to build a model based on the training data.

[0301] Step 10:

[0302] The server performs cross-validation and evaluates the accuracy of the model.

[0303] Step 11:

[0304] The server uses an emotion engine to recognize emotions based on user input. For example, if the user answers "anxious," the emotion engine processes that emotional state as data.

[0305] Step 12:

[0306] The emotion engine transmits the recognized emotion information to the server, and the server adjusts the prediction result and countermeasure plan based on this information.

[0307] Step 13:

[0308] When the user inputs new litigation information and emotion information, the server predicts the winning probability using the learned model based on this information.

[0309] Step 14:

[0310] The server presents the optimal countermeasure plan to the user based on the predicted winning probability and the information of the emotion engine. For example, when the winning probability is 75% and the user is feeling high stress, in addition to the action plans of "recheck the terms of the contract" and "submit additional evidentiary documents", the server proposes "consult with an expert in a relaxing environment".

[0311] Specific example

[0312] 1. Specific example of data collection

[0313] The user is considering a "litigation due to breach of contract" and inputs information about the name of the judge and past cases. In response, the server retrieves similar litigation data from the past 10 years and the latest legal amendment information from the database.

[0314] 2. Specific example of data preprocessing

[0315] The server preprocesses the acquired data. For example, if there are missing values, it uses the average value of past similar data for complementation. For non-numeric data, it converts the text into numeric values.

[0316] 3. Specific example of feature extraction

[0317] When the type of litigation is "breach of contract", the server extracts the features (such as the content of the contract and the presence or absence of evidence) that affect the result of similar litigations from past judicial data.

[0318] 4. Specific Examples of Model Learning

[0319] The server builds a machine learning model using contract breach litigation data and evaluates its accuracy using cross-validation.

[0320] 5. Specific examples of emotion recognition

[0321] When a user inputs emotional information into their device, they select an emotion such as "anxiety," "anticipation," or "stress." The emotion engine then analyzes this information to recognize the user's emotional state.

[0322] 6. Specific examples of predictions and proposed countermeasures

[0323] Based on the newly provided litigation and emotional information from the user, the server predicts a "75% chance of winning" using data from the emotional engine. For example, if the user is feeling anxious, it suggests "revising the contract clauses and submitting additional evidence" as well as "consulting a psychological counselor."

[0324] This system not only assists in decision-making when considering litigation, but also supports more appropriate and effective litigation preparation by providing countermeasures that take into account the user's emotional state.

[0325] (Example 2)

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

[0327] Conventional litigation support systems have a problem in that they predict the probability of winning a lawsuit and suggest countermeasures without considering the user's emotional state, making it difficult for users to make informed decisions. Furthermore, the accuracy of predictions is also hampered by incomplete or redundant input data.

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

[0329] In this invention, the server includes means for collecting data from a historical database, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to the lawsuit, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, means for presenting the prediction results and proposed countermeasures, means for inputting and analyzing emotional information from the user, and means for dynamically adjusting the prediction results and proposed countermeasures based on the analyzed emotional information. This makes it possible to predict the probability of winning with high accuracy and present appropriate countermeasures that take into account the user's emotional state.

[0330] "Data collection" is the process of gathering necessary information from past databases.

[0331] "Data cleansing" is the process of removing inaccurate or duplicate data from collected data.

[0332] "Missing value imputation" is the process of filling in missing values ​​in a dataset with appropriate values.

[0333] "Feature extraction" is the process of selecting features from data that may influence the outcome of a lawsuit.

[0334] "Encoding" is the process of converting categorical data into numerical data.

[0335] A "machine learning model" is a collection of algorithms trained to make predictions and classifications based on data.

[0336] "Model training" is the process of training a machine learning model using collected data.

[0337] "Predicting the probability of winning a lawsuit" is the process of calculating the probability of winning a lawsuit using a trained machine learning model.

[0338] "Prediction result" refers to the output value calculated by the machine learning model.

[0339] "Presenting proposed solutions" means providing users with guidance on what to do based on the prediction results.

[0340] "Emotional information" refers to data that indicates the user's mental state.

[0341] "Emotional analysis" is the process of evaluating a user's mental state based on the emotional information they have entered.

[0342] "Dynamic adjustment" refers to changing the system's behavior and output in real time based on analyzed emotional information.

[0343] This invention relates to a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation. The system consists of a server, a user terminal, a database, and an emotion engine. The user terminal provides an interface for inputting litigation information and the user's emotions, while the server performs data collection, preprocessing, feature extraction, model training, prediction, and results presentation. The emotion engine recognizes the user's emotions and improves the system's performance.

[0344] Hardware and software to be used

[0345] Server: A server with high-performance computing capabilities is required. For example, a server equipped with an Intel processor would be used.

[0346] User terminal: This refers to a device used by the user to input data, such as a personal computer or smartphone. For example, devices running Windows or iOS are suitable.

[0347] Database: A database is needed to store past litigation information and legal data. A relational database such as MySQL or PostgreSQL will be used.

[0348] Emotion Engine: This software uses natural language processing (NLP) or emotion analysis engines to analyze user emotion information. Examples include open-source emotion analysis libraries such as NLTK and TextBlob.

[0349] Machine learning libraries: Machine learning libraries such as TENSORFLOW® and Scikit-learn are used to build and train models.

[0350] Explanation of the process

[0351] Data collection

[0352] Users input information about the lawsuit (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information through their device. For example, if a user is considering a "breach of contract lawsuit," they would input the judge's name and information about past cases.

[0353] The server receives this input information and collects relevant data from its historical litigation database. It also collects information on legal amendments and recent case precedents from its up-to-date legal database. For example, it retrieves data on similar litigation from the past 10 years and information on recent legal amendments.

[0354] Data preprocessing

[0355] The server cleanses the collected data, removing inaccurate and duplicate entries. For example, it might delete duplicate records for the same case.

[0356] The server identifies data with missing values ​​and imputes them using statistical methods. For example, it might fill in missing values ​​with the mean of past data.

[0357] The server converts the data into a format that machine learning algorithms can easily process. For example, it encodes text data into categorical data and converts it into numerical data.

[0358] Feature extraction

[0359] The server selects features from past litigation data that may influence the outcome of a lawsuit. For example, in a "breach of contract" lawsuit, the content of the contract and the presence or absence of evidence are important features.

[0360] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data. For example, it assigns a unique numerical ID to a judge's name.

[0361] Model Learning

[0362] The server splits the dataset into training data and test data, and then builds a model based on the training data using the selected machine learning model. For example, it might split the dataset into 80% training data and 20% test data.

[0363] The server performs cross-validation to evaluate the model's accuracy. For example, it verifies the model's accuracy by performing k-fold cross-validation.

[0364] emotion recognition

[0365] The user inputs emotional information into the device. For example, they might input emotions such as "high stress" or "feeling relieved."

[0366] The emotion engine analyzes the input emotion information to identify the user's emotional state. For example, it uses natural language processing to analyze emotions from user input.

[0367] The server dynamically adjusts prediction results and suggested actions based on emotional information obtained from the emotion engine. For example, if the user is feeling stressed, a relaxation message will be added to the suggested actions.

[0368] Prediction and Analysis

[0369] When a user enters new litigation and sentiment information, the server uses a trained model to predict the probability of winning. For example, it might display "75% probability of winning this breach of contract lawsuit."

[0370] Based on information from the emotion engine, the server presents the user with the most suitable course of action. For example, it provides specific action plans such as "review the contract terms" or "submit additional supporting documents."

[0371] Specific example

[0372] If a user is considering a "breach of contract lawsuit," they enter information such as "Judge's name: X, Lawyer's name: Y, Summary of the lawsuit" into their device. The server receives this information and collects similar lawsuit data from its database of past lawsuits. Additionally, if the user enters "I am feeling stressed," the emotion engine analyzes this, and the server provides additional suggestions for countermeasures corresponding to the stress level.

[0373] This system supports decision-making in litigation and provides optimal solutions that take into account the user's emotional state, thereby assisting in effective litigation preparation.

[0374] Example of a prompt:

[0375] "I am considering a lawsuit for breach of contract. The judge's name is X, and my lawyer is Y. The details of the lawsuit are as follows... I am currently experiencing stress."

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

[0377] Step 1:

[0378] Data collection

[0379] Users input litigation information (e.g., type of lawsuit, judge's name, legal documents) and sentiment information through their device. An example of input might be "breach of contract lawsuit, Judge X, Lawyer Y".

[0380] The terminal sends the entered information to the server. At this time, the input information is sent in JSON format or similar.

[0381] The server receives the input information and collects relevant historical litigation data and current legal data from the database. For example, it extracts contract breach litigation data from the past 10 years.

[0382] Input: litigation information, sentiment information

[0383] Output: Past litigation data, legal data

[0384] Step 2:

[0385] Data preprocessing

[0386] The server cleanses the received data, removing inaccurate and duplicate entries. Specifically, this involves actions such as "deleting records with blank judge names" and "merging duplicate litigation data."

[0387] The server identifies missing values ​​and imputes them based on statistical methods. For example, "if past data for Judge Y is missing, it will impute it with the mean."

[0388] The server converts text data into numerical data. For example, it encodes "the judge's name" into a categorical ID.

[0389] Input: Collected litigation data, legal data

[0390] Output: Cleansed and imputed data

[0391] Step 3:

[0392] Feature extraction

[0393] The server extracts features that influence the outcome of a lawsuit. Specifically, it selects features such as "type of lawsuit," "judge's tendencies," and "lawyer's years of experience."

[0394] The server encodes categorical data into numerical data. For example, it converts "Judge X" to "Category ID 1".

[0395] Input: Preprocessed litigation data

[0396] Output: Feature data

[0397] Step 4:

[0398] Model Learning

[0399] The server splits the litigation data into training data and test data. Specifically, it uses "80% as training data and 20% as test data."

[0400] The server uses a selected machine learning model (e.g., Random Forest) to build a model based on the training data.

[0401] The server performs cross-validation to evaluate the model's accuracy. For example, it checks the model's accuracy using "k-fold cross-validation".

[0402] Input: Feature data

[0403] Output: Trained model, model accuracy evaluation results

[0404] Step 5:

[0405] emotion recognition

[0406] The user inputs emotional information into the device. For example, they might input information such as "Stress level: High" and "Sense of security: Low."

[0407] The emotion engine analyzes the input emotional information. Specifically, it uses natural language processing to determine that the user is "highly stressed."

[0408] The server dynamically adjusts prediction results and suggested actions based on emotional information obtained from the emotion engine. For example, if the user enters "high stress level," a relaxation message will be added.

[0409] Input: User sentiment information

[0410] Output: Analyzed sentiment data

[0411] Step 6:

[0412] Prediction and Analysis

[0413] When a user enters new litigation and sentiment information, the server uses a trained model to predict the probability of winning. Specifically, it will display something like, "75% probability of winning this breach of contract lawsuit."

[0414] Based on information from the emotion engine, the server presents the user with the most suitable course of action. Specific action plans might include suggestions such as "review the contract clauses" or "consult with a lawyer in a relaxed environment."

[0415] Input: New litigation information, analyzed sentiment data

[0416] Output: Probability of winning the case, proposed countermeasures

[0417] (Application Example 2)

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

[0419] While systems exist that predict the probability of winning a case and provide appropriate countermeasures based on past precedents and the latest legal information when considering litigation, few systems provide countermeasures that take into account the user's emotional state. Under high-stress conditions, users are less likely to make optimal decisions, resulting in inefficient litigation preparation. Furthermore, dynamically updating litigation information and providing timely advice tailored to the user's emotional state is also difficult. Solving these problems is the objective of this invention.

[0420] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for collecting data from past databases, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to the lawsuit, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, means for recognizing the user's emotional state, means for presenting countermeasures based on the emotional state, and means for providing new lawsuit information and dynamic countermeasures based on the emotional state. This makes it possible to predict the probability of winning with high accuracy based on past precedents and the latest legal information while taking the user's emotional state into consideration, and to provide prompt and appropriate advice.

[0421] definition statement

[0422] "Data collection" is the process of obtaining past case precedents, legal information, and user litigation information from a database.

[0423] "Data cleansing" is the process of removing inaccurate or duplicate data from collected data.

[0424] "Missing value imputation" is the process of filling in missing data based on the mean or existing data.

[0425] "Feature extraction" is a technique for selecting data that may influence the outcome of a lawsuit and converting it into a format that is easy to analyze.

[0426] "Encoding" is the process of converting categorical data into numerical data.

[0427] A "machine learning model" is an algorithm that performs predictions and classifications based on past data.

[0428] "Model learning" is the process of feeding data to a machine learning model to improve its prediction accuracy.

[0429] "Predicting the probability of winning a lawsuit" is the process of predicting the likelihood of winning a lawsuit as a numerical value.

[0430] "Emotion recognition" is a technology that recognizes a user's emotional state from the information they input.

[0431] "Presenting proposed solutions" is the process of providing specific action plans and advice tailored to the user's situation.

[0432] "Dynamic solution provision" refers to a technology that provides solutions in real time based on updated litigation information and emotional states.

[0433] Modes for carrying out the invention

[0434] System Configuration

[0435] The system for carrying out this invention consists of the following main components.

[0436] 1. Server: Performs data collection, cleansing, missing value imputation, feature extraction, encoding, machine learning model training, sentiment recognition, win probability prediction, and proposal of countermeasures.

[0437] 2. User terminal: Provides an interface for inputting litigation information and emotional state, and receiving prediction results and proposed countermeasures.

[0438] 3. Database: Stores past litigation data, legal documents, and the latest information on legal amendments.

[0439] 4. Emotion Engine: Analyzes the user's emotional state and provides data to improve the system's effectiveness.

[0440] Hardware and software to be used

[0441] Hardware: Computer servers, smartphones, network infrastructure

[0442] Software: Python, Pandas, Scikit-learn, emotion_recognition library, database management system

[0443] Program processing

[0444] Data Collection: The server collects necessary data from past litigation databases, user input, and the latest legal databases. This includes the type of litigation, judge information, and relevant legal documents.

[0445] Data cleansing and missing value imputation: The server cleanses the collected data, removing inaccurate and duplicate data. Furthermore, it imputates missing data using mean values ​​and other statistical methods.

[0446] Feature extraction and encoding: The server extracts key features relevant to the litigation and encodes categorical data into numerical data.

[0447] Machine learning model training: The server uses these features to train a machine learning model and evaluates the model's accuracy through cross-validation.

[0448] Emotion Recognition: The system receives emotional information input from the user's device and uses an emotion engine to identify the user's emotional state.

[0449] Predicting the probability of winning: Based on new litigation information and the user's emotional state, the server uses a model to predict the probability of winning.

[0450] Proposal of countermeasures: The server provides the user with the optimal countermeasures based on the prediction results and emotional state.

[0451] Specific example

[0452] For example, if a user is considering a lawsuit for breach of contract, they would input information such as the judge's name and details of past cases. Based on this information, the server would collect relevant data from its historical database and obtain the latest legal information. Next, the server would cleanse the data and impute any missing values. It would use a machine learning model to predict the probability of winning and an emotion engine to recognize the user's emotional state. As a result, the server would predict that there is a "75% chance of winning" and, if the user's emotional state indicates stress, would suggest a course of action such as "consulting with a lawyer in a relaxing environment."

[0453] Example of a prompt

[0454] User input:

[0455] "I am very worried about this lawsuit."

[0456] Emotion recognition prompt:

[0457] "Based on this text, identify the user's emotions, recognize their emotional state (e.g., high stress, feeling at ease), and output the results."

[0458] In this way, the system can provide more appropriate advice based on the user's emotional state and assist in preparing for litigation.

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

[0460] Program processing steps

[0461] Step 1:

[0462] Data collection

[0463] Input: The user enters litigation information (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information into the device.

[0464] Specific operation: The user uses their device to enter litigation-related information into forms and fields. This information is then sent from the device to the server.

[0465] Data processing / calculation: The server uses the received input information as a database query to collect historical litigation data and the latest legal information from the database.

[0466] Output: A set of collected litigation data and legal documents.

[0467] Step 2:

[0468] Data cleansing and missing value imputation

[0469] Input: The dataset collected in Step 1.

[0470] Specific operation: The server analyzes the collected dataset and removes redundant or inaccurate data. Next, it identifies missing data and fills it in using statistical methods (e.g., mean imputation).

[0471] Data processing / calculations: Deleting duplicate data, identifying and imputing missing values.

[0472] Output: Cleansed dataset with no missing values.

[0473] Step 3:

[0474] Feature extraction and encoding

[0475] Input: The dataset cleansed in Step 2.

[0476] Specific operation: The server selects features that may influence the outcome of a lawsuit (e.g., the type of lawsuit and the judge's ruling tendencies). It also encodes categorical data (e.g., the judge's name and the type of lawsuit) into numerical data.

[0477] Data processing / calculations: Feature extraction, numerical conversion of categorical data.

[0478] Output: A dataset with extracted and encoded features.

[0479] Step 4:

[0480] Training machine learning models

[0481] Input: The feature dataset created in Step 3.

[0482] Specific operation: The server splits the dataset into training and test data, and builds a model based on the training data using a selected machine learning model (e.g., Random Forest). Cross-validation is performed to evaluate the accuracy of the model.

[0483] Data processing / computation: Data splitting, model training, and evaluation using cross-validation.

[0484] Output: Trained machine learning model.

[0485] Step 5:

[0486] emotion recognition

[0487] Input: Sentimental information (text data) from the user's terminal.

[0488] Specific operation: The server receives emotional information entered by the user on the device (for example, "I feel very uneasy about this lawsuit"). The server uses the emotion_recognition library to analyze the entered text and recognize the emotional state.

[0489] Data processing / calculation: Analysis of text data, recognition of emotional states.

[0490] Output: Recognized emotional state (e.g., "anxiety").

[0491] Step 6:

[0492] Prediction of the probability of winning the case

[0493] Input: Trained model, Step 3 feature data, new litigation information, Step 5 sentiment state.

[0494] Specific operation: The server uses a pre-trained model to predict the probability of winning the case, taking into account new litigation information and emotional states.

[0495] Data processing / calculation: Inputting feature data into the model, calculating the probability of winning.

[0496] Output: Predicted probability of winning the case.

[0497] Step 7:

[0498] Presentation of countermeasures

[0499] Input: Predicted probability of winning the case, emotional state.

[0500] Specific operation: The server generates optimal countermeasures based on the predicted probability of winning the case and the user's emotional state. For example, if the probability of winning is high and the user is feeling stressed, it will create specific advice such as "consult with a lawyer in a relaxing environment."

[0501] Data processing / calculation: Analysis of prediction results and emotional states, generation of countermeasures.

[0502] Output: Proposed countermeasures as notifications to the user's terminal.

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

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

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

[0506] [Second Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0519] System Configuration

[0520] This invention is a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation, and consists of a server, a user terminal, and a database. The user terminal provides an interface for inputting litigation information, and the server performs data collection, preprocessing, feature extraction, model training, prediction, and result presentation.

[0521] System program processing

[0522] 1. Data Collection

[0523] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) via their device.

[0524] The server receives this input information and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[0525] 2. Data preprocessing

[0526] The server cleanses the collected data, removing inaccurate and duplicate data.

[0527] The server identifies data with missing values ​​and imputes them. For example, it might use statistical methods to impute them with the mean, or predict them based on past trends.

[0528] The server converts the data into a format that is easy for machine learning algorithms to process, and converts text data into numerical data.

[0529] 3. Feature Extraction

[0530] The server selects features from past litigation data that may influence the outcome of a lawsuit. Specific examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[0531] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[0532] 4. Model Learning

[0533] The server splits the dataset into training data and test data, and then builds a model based on the training data using the selected machine learning model.

[0534] The server performs cross-validation and evaluates the accuracy of the model.

[0535] 5. Prediction and Analysis

[0536] When a user enters new litigation information, the server uses a pre-trained model to predict the probability of winning the case based on that information.

[0537] Along with the predicted probability of winning the case, the server presents the user with specific countermeasures. For example, it might suggest concrete action plans such as "review the contract clauses" or "submit additional supporting documents."

[0538] Specific example

[0539] 1. Specific examples of data collection

[0540] For example, if a user is considering a "breach of contract lawsuit," they would enter the judge's name and information about past cases. The server would then retrieve similar lawsuit data from the past 10 years and the latest legal amendments from its database.

[0541] 2. Specific Examples of Data Preprocessing

[0542] The server preprocesses the retrieved data; for example, if there are missing values, it uses the average of similar historical data to fill them in. For non-numeric data, it converts the text to numbers.

[0543] 3. Specific Examples of Feature Extraction

[0544] If the type of lawsuit is "breach of contract," the server extracts features from past court data that influence the outcome of similar lawsuits (e.g., the content of the contract and the presence or absence of evidence).

[0545] 4. Specific Examples of Model Learning

[0546] The server builds a machine learning model using contract breach litigation data and evaluates its accuracy using cross-validation.

[0547] 5. Specific examples of predictions and proposed countermeasures

[0548] When a user provides new litigation information, the server predicts a "75% chance of winning" and suggests specific countermeasures such as "revising the contract clauses and submitting additional evidence."

[0549] This system assists decision-making when considering litigation and provides support to help users proceed with litigation from a more advantageous position.

[0550] The following describes the processing flow.

[0551] Step 1:

[0552] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) via their device.

[0553] Step 2:

[0554] The server receives user input information and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[0555] Step 3:

[0556] The server cleanses the collected data, removing inaccurate and duplicate data.

[0557] Step 4:

[0558] The server identifies data with missing values ​​and imputes them using statistical methods. For example, it might use the mean to impute them.

[0559] Step 5:

[0560] The server converts the data into a format that machine learning algorithms can easily process. Specifically, it converts text data into numerical data.

[0561] Step 6:

[0562] The server selects features from past litigation data that may influence the outcome of a lawsuit. Examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[0563] Step 7:

[0564] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[0565] Step 8:

[0566] The server splits the dataset into training and test data. This makes it easier to evaluate the generalization performance of the model.

[0567] Step 9:

[0568] The server uses the selected machine learning model to build a model based on the training data.

[0569] Step 10:

[0570] The server performs cross-validation and evaluates the accuracy of the model.

[0571] Step 11:

[0572] When a user enters new litigation information, the server uses a pre-trained model to predict the probability of winning the case based on that information.

[0573] Step 12:

[0574] The server presents the user with a predicted probability of winning the case, along with specific countermeasures. For example, it might suggest concrete action plans such as "review the contract clauses" or "submit additional supporting documents."

[0575] (Example 1)

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

[0577] Conventional litigation support systems struggle to provide reliable data analysis and concrete strategies for users to predict the probability of winning a lawsuit. In particular, traditional methods are inefficient at processing inaccurate and duplicate data, imputing missing data, extracting and encoding features, and evaluating the accuracy of machine learning models, resulting in insufficient support for user decision-making.

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

[0579] In this invention, the server includes means for dynamically collecting information from a past database based on litigation information entered by the user; means for cleansing the collected information, removing inaccurate and duplicate data, and supplementing missing data; means for selecting features that affect the outcome of the litigation and encoding categorical data into numerical data; means for building a model based on training data using a machine learning model and evaluating the accuracy of the model by cross-validation; means for predicting the probability of winning from newly entered litigation information based on the trained model; and means for presenting specific countermeasures along with the prediction results. This makes it possible to predict the probability of winning with high accuracy and to present specific and effective litigation countermeasures.

[0580] A "user" is an individual or organization that uses the system to input litigation information and receives predictions of the probability of winning and suggestions for countermeasures.

[0581] "Terminal" refers to a device used by a user to input litigation information, and includes personal computers, smartphones, tablets, etc.

[0582] A "server" is a central processing unit that processes information entered by users and performs data collection, data preprocessing, feature extraction, model training, prediction, and result presentation.

[0583] A "database" is an information storage system used to manage and retrieve past litigation data and the latest legal information.

[0584] "Data cleansing" is the process of removing inaccurate or duplicate data from collected information to improve data consistency and reliability.

[0585] "Missing data imputation" is the process of filling in missing values ​​in a dataset using statistical methods or other data points.

[0586] "Feature extraction" is a process used to identify important data items that may influence the outcome of a lawsuit and to analyze litigation information.

[0587] "Category data encoding" is the process of converting text or categorical data into numerical data that can be processed by machine learning.

[0588] A "machine learning model" is an algorithm that is trained using historical data and then used to make predictions and classifications on new data.

[0589] Cross-validation is a technique for evaluating the generality and accuracy of a model by dividing the training data and performing multiple training and evaluation iterations.

[0590] "Predicting the probability of winning a case" is the process of using a pre-trained model to numerically calculate the likelihood of winning a case based on new litigation information.

[0591] "Presenting countermeasures" is the process of proposing specific actions and strategies that users should take based on the predicted probability of winning the case.

[0592] The following describes in detail the embodiments for which this invention is specifically implemented.

[0593] System Configuration

[0594] This invention is a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation, and consists of a server, a user terminal, and a database. The user terminal provides an interface for inputting litigation information, and the server performs data collection, preprocessing, feature extraction, model training, prediction, and result presentation.

[0595] Hardware and software to be used

[0596] 1. Hardware

[0597] User terminal: A device such as a personal computer, smartphone, or tablet.

[0598] Server: A central processing unit for data processing. A server equipped with a high-performance processor.

[0599] Database: A storage system for managing litigation data. Specifically, MySQL will be used.

[0600] 2. Software

[0601] Data cleansing and imputation: Using the Python Pandas library.

[0602] Feature extraction and encoding: Use CountVectorizer and One-Hot encoding from the Scikit-learn library.

[0603] Model training and accuracy evaluation: Use RandomForestClassifier and cross-validation from the Scikit-learn library.

[0604] Program processing

[0605] 1. Data Collection

[0606] The user enters litigation information through their device. This information includes the type of lawsuit, the judge's information, and relevant legal documents.

[0607] The server receives input information in real time and collects historical litigation data and the latest legal information. Specifically, it uses the Flask framework in Python to receive data and retrieves relevant information from a MySQL database.

[0608] 2. Data preprocessing

[0609] The server cleanses the collected data, removing inaccurate and duplicate entries. This is done using the Python Pandas library.

[0610] The server will impute missing data. Missing values ​​will be filled in using statistical methods, specifically by calculating the mean using the Pandas library.

[0611] The server converts the data format into one that is easily processed by machine learning algorithms. Text data is converted to numerical data using CountVectorizer.

[0612] 3. Feature Extraction

[0613] The server extracts features that influence the outcome of the lawsuit. This process uses the Scikit-learn library to select features such as the type of lawsuit, the judge's ruling tendencies, and the lawyer's experience.

[0614] The server encodes categorical data into numerical data. One-hot encoding is used to convert categorical data into numerical data.

[0615] 4. Model Learning

[0616] The server splits the dataset into training and test data and builds a model using the RandomForestClassifier from the Scikit-learn library.

[0617] The server performs cross-validation to evaluate the model's accuracy. This verifies the model's generality and accuracy.

[0618] 5. Prediction and Analysis

[0619] When a user enters new litigation information, the server uses a pre-trained model to predict the probability of winning the case.

[0620] Based on the prediction results, the server presents the user with specific countermeasures. For example, in the case of a breach of contract lawsuit, it might display a "75% chance of winning" and suggest "revise the contract clauses and submit additional supporting documents."

[0621] Specific example

[0622] 1. Example of data collection

[0623] The user considers filing a "breach of contract lawsuit" and enters the judge's name and details of the lawsuit into their terminal. The server receives this information and collects similar lawsuit data from its MySQL database.

[0624] 2. Examples of data preprocessing

[0625] The server cleanses the collected data using the Pandas library and imputes missing data. For example, it might use the mean of similar historical data to impute missing values.

[0626] 3. Examples of Feature Extraction

[0627] If the type of lawsuit is "breach of contract," the server extracts features such as the content of the contract and the presence or absence of evidence from past court data.

[0628] 4. Examples of Model Learning

[0629] The server uses contract breach litigation data to build a machine learning model with RandomForestClassifier and performs cross-validation.

[0630] 5. Examples of Predictions and Proposed Countermeasures

[0631] When a user enters new litigation information, the server predicts a "75% chance of winning" and suggests specific countermeasures such as "re-examining the contract clauses" or "submitting additional evidence."

[0632] Example of a prompt

[0633] "We are considering filing a lawsuit for breach of contract. Based on past data from similar lawsuits and the latest legal information, please predict the probability of winning and propose specific countermeasures."

[0634] This system will enable effective support for users' decision-making when considering litigation.

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

[0636] Step 1:

[0637] The user enters litigation information via their device. This input includes the type of litigation, judge information, and relevant legal documents. For example, if the user is considering a "breach of contract lawsuit," they would enter the judge's name and details of the lawsuit. Input: Litigation information (e.g., type of litigation, judge's name, relevant legal documents). Output: Litigation information sent to the endpoint.

[0638] Step 2:

[0639] The server receives litigation information submitted by users in real time. Based on the received information, it executes queries to collect relevant information from historical litigation databases and current legal databases. Specifically, it uses the Flask framework in Python to receive data and retrieve the necessary information from a MySQL database. Input: Litigation information submitted to the endpoint. Output: Historical litigation data and current legal information.

[0640] Step 3:

[0641] The server cleanses the collected data. Specifically, it uses the Pandas library to remove inaccurate and duplicate data. Next, it imputes missing data and converts text data to numerical data. The mean of similar historical data is used to impute missing values. For example, the mean of similar historical litigation data is used to impute missing values. Input: Historical litigation data and recent legal information. Output: Preprocessed dataset.

[0642] Step 4:

[0643] The server extracts features from a preprocessed dataset and encodes categorical data into numerical data. The Scikit-learn library is used for feature extraction, selecting important features (e.g., type of lawsuit, judge's ruling tendencies, lawyer's experience). Categorical data is converted to numerical data using one-hot encoding. Input: Preprocessed dataset. Output: Feature-extracted and encoded dataset.

[0644] Step 5:

[0645] The server trains a machine learning model using a feature-extracted dataset. It splits the dataset into training and test data, and builds and trains the model using the RandomForestClassifier from the Scikit-learn library. The model's accuracy is evaluated using cross-validation. Input: Feature-extracted and encoded dataset. Output: Trained machine learning model and its evaluation results.

[0646] Step 6:

[0647] When a user enters new litigation information, the server predicts the probability of winning based on a trained model. The entered litigation information is fed into the model, and the prediction result is calculated. For example, when new litigation information is entered, "75% probability of winning" is displayed. Input: New litigation information. Output: Predicted probability of winning result.

[0648] Step 7:

[0649] The server presents the user with specific countermeasures based on the prediction results. For example, it might suggest concrete action plans such as "revise the contract clauses and submit additional supporting documents." This allows the user to proceed with the lawsuit from a more advantageous position. Input: Predicted probability of winning. Output: Specific countermeasures.

[0650] Through the processing steps described above, this system provides users with the necessary information analysis and countermeasures when proceeding with litigation, thereby supporting their decision-making.

[0651] (Application Example 1)

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

[0653] Conventional litigation support systems have suffered from insufficient prediction and countermeasures based on past precedents and legal amendments. As a result, users have difficulty making decisions when considering litigation, and risk management is not adequately implemented. Furthermore, there was no means to dynamically analyze the information users entered regarding legal issues and appropriately present specific countermeasures, thus requiring a swift and accurate response.

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

[0655] In this invention, the server includes means for collecting data from a historical database, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to the lawsuit, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, means for receiving input of legal issues from users, visualizing and displaying the results, and means for dynamically generating and presenting specific countermeasures. This enables dynamic analysis when a user inputs a legal issue, allowing for appropriate prediction of the probability of winning and presentation of specific countermeasures.

[0656] A "historical database" is a data storage system that preserves past precedents and legal document information related to litigation.

[0657] "Means of data collection" refers to techniques or methods for extracting necessary data from specific sources and storing it in a database.

[0658] "Data cleansing techniques" are techniques or methods for removing inaccurate or duplicate data in order to improve data quality.

[0659] "Missing value imputation" is the process of appropriately filling in missing data present in a portion of a dataset using statistical methods or inference.

[0660] "Means for extracting features relevant to litigation" refers to techniques or methods for selecting important attributes or elements that influence the outcome of litigation.

[0661] "Encoding means" refers to techniques or methods that convert categorical data into numerical data that can be processed by machine learning algorithms.

[0662] A "machine learning model" is a mathematical algorithm or statistical model that learns patterns and trends based on training data to perform predictions and classifications.

[0663] "Means of building and training" refers to techniques or methods for creating a model using training data and then optimizing its performance.

[0664] "Methods for predicting the probability of winning a case" refer to techniques or methods for probabilistically evaluating the outcome of a lawsuit based on a model.

[0665] "Means of receiving input on legal issues" refers to a technology or method for incorporating legal information provided by users into a system through an interface.

[0666] "Means of visualizing and displaying results" refers to techniques or methods for presenting data or prediction results to users in a visual format such as graphs or charts.

[0667] "Means for dynamically generating and presenting specific countermeasures" refers to a technology or method that generates and proposes actionable countermeasures in real time based on user input information.

[0668] This invention relates to a "corporate compliance monitoring application" that enables companies to anticipate legal issues in advance and take concrete countermeasures. This system consists of a server, user terminals, and a database.

[0669] System Configuration

[0670] The server uses hardware and software to perform the following functions:

[0671] For data collection and cleansing, we use database management systems (MySQL, PostgreSQL) and data analysis libraries (Pandas).

[0672] Feature extraction and encoding will be performed using the machine learning library (Scikit-learn).

[0673] Random Forest is used to build and train machine learning models.

[0674] The user terminal provides an interface for legal personnel to input information on legal issues and visually displays predicted results and proposed solutions from the server. A web browser or mobile application is used for the graphical user interface (GUI).

[0675] The database stores past case precedents and information on legal amendments, and is used by the server to dynamically search and extract the necessary data.

[0676] System processing

[0677] 1. Data collection:

[0678] The server receives information about legal issues sent from user terminals and collects relevant past case data and the latest legal amendment information from its database.

[0679] 2. Data preprocessing:

[0680] The server cleanses the collected data, removing inaccurate and duplicate data. Furthermore, it imputes missing values ​​and encodes categorical data into numerical data.

[0681] 3. Feature extraction and model training:

[0682] The server extracts features relevant to the lawsuit and builds a machine learning model based on historical data. The model's accuracy is evaluated using cross-validation.

[0683] 4. Predictions and proposed countermeasures:

[0684] When a new legal issue is entered by a user, the server predicts the probability of winning the case based on its model and dynamically generates and presents specific countermeasures. The prediction results and countermeasures are displayed visually on the user's terminal.

[0685] Program Processing Description

[0686] The server first receives information about legal issues and collects relevant data from historical databases. During the data collection process, a database management system (MySQL, PostgreSQL) is used to search for and extract the necessary data. Subsequently, the Pandas data analysis library is used to cleanse the data and impute missing values.

[0687] Next, the server extracts features related to the lawsuit from the collected data and encodes them into numerical data. Scikit-learn is used for this process. The Random Forest algorithm is employed for model construction and training, and the model's accuracy is evaluated by performing cross-validation.

[0688] When a user enters a new legal issue, the server predicts the probability of winning based on a trained model and displays this visually on the user's terminal. In addition, it dynamically generates proposed solutions and presents the user with a concrete action plan. This allows the user to take quick and appropriate action.

[0689] Specific example

[0690] For example, if a user is considering a "breach of contract lawsuit," they enter the judge's name and information about past cases. The server then retrieves data on similar lawsuits from the past 10 years and the latest legal amendments from its database and processes it. As a result, it displays a "75% chance of winning" and suggests countermeasures such as "reviewing the contract clauses and submitting additional evidence."

[0691] An example of a prompt message for a generative AI model is: "Build a model to predict the probability of winning a current legal issue based on past case data collected by a compliance monitoring application. Use features such as the type of legal issue, judge information, and legal documents to predict the probability of winning and create a prompt message that suggests specific countermeasures."

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

[0693] Step 1:

[0694] Data collection

[0695] The server receives information about the legal issue entered by the user (e.g., type of lawsuit, judge information, relevant documents). Based on this input, the server collects relevant case law data and the latest legal amendment information from its historical database.

[0696] Input: Information on legal issues

[0697] Output: Collected historical case law data and information on legal amendments.

[0698] Specifically, the server uses a database management system (MySQL, PostgreSQL) to query and retrieve the relevant data. For example, it might collect data on contract breaches over the past 10 years or information on the latest legal changes.

[0699] Step 2:

[0700] Data preprocessing

[0701] The server cleanses the collected data, removing inaccurate and duplicate data. If the collected data contains missing values, statistical methods are used to impute them.

[0702] Input: Collected historical case law data and information on legal amendments.

[0703] Output: Cleansed and imputed data

[0704] Specifically, the data is preprocessed using the Pandas data analysis library. Inaccurate and duplicate data are removed, and missing values ​​are imputed by predicting them from the mean or historical trends.

[0705] Step 3:

[0706] Feature extraction and encoding

[0707] The server extracts features from the cleansed data that could potentially influence the outcome of the lawsuit and encodes categorical data into numerical data.

[0708] Input: Cleansed data

[0709] Output: Data with extracted and encoded features

[0710] Specifically, the Scikit-learn library is used to quantify features such as the type of lawsuit, the judge's tendencies, and the content of legal documents. Categorical data is converted to numerical values ​​using LabelEncoder.

[0711] Step 4:

[0712] Model Learning

[0713] The server builds a machine learning model based on the data from which features have been extracted and encoded, and then trains it using the training data. After training, cross-validation is performed to evaluate the accuracy of the model.

[0714] Input: Data from which features have been extracted and encoded.

[0715] Output: Trained machine learning model

[0716] The server builds a model using the RandomForest algorithm from the Scikit-learn library, splits the data into training and test sets, and trains the model. Cross-validation is used to evaluate the model's accuracy and select the optimal model.

[0717] Step 5:

[0718] Predictions and proposed countermeasures

[0719] When a user inputs information about a new legal issue, the server predicts the probability of winning based on a trained model. It visualizes the prediction and displays it on the user's terminal, dynamically generating and proposing specific countermeasures.

[0720] Input: Information on new legal issues

[0721] Output: Predicted probability of winning the case and specific countermeasures.

[0722] Specifically, the server inputs data on new legal issues into a pre-trained model and obtains a predicted probability of winning. It then uses visualization tools to display the results in graphs and charts and presents specific countermeasures (e.g., reviewing contract clauses and submitting additional evidence).

[0723] Examples of prompts for a generative AI model:

[0724] "Based on past case data collected by a compliance monitoring application, we will build a model to predict the probability of winning current legal issues. Using features such as the type of legal issue, judge information, and legal documents, we will predict the probability of winning and create prompt messages suggesting specific countermeasures."

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

[0726] System Configuration

[0727] This invention relates to a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation, and consists of a server, a user terminal, a database, and an emotion engine. The user terminal provides an interface for inputting litigation information and the user's emotions, the server collects data, preprocesses it, extracts features, trains the model, makes predictions, and presents results, and the emotion engine recognizes the user's emotions and improves the system's performance.

[0728] System program processing

[0729] 1. Data Collection

[0730] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information via their device.

[0731] The server receives this input information and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[0732] 2. Data preprocessing

[0733] The server cleanses the collected data, removing inaccurate and duplicate data.

[0734] The server identifies data with missing values ​​and imputes them. For example, it might use statistical methods to impute them with the mean.

[0735] The server converts the data into a format that is easy for machine learning algorithms to process, and converts text data into numerical data.

[0736] 3. Feature Extraction

[0737] The server selects features from past litigation data that may influence the outcome of a lawsuit. Specific examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[0738] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[0739] 4. Model Learning

[0740] The server splits the dataset into training data and test data, and then builds a model based on the training data using the selected machine learning model.

[0741] The server performs cross-validation and evaluates the accuracy of the model.

[0742] 5. Emotion recognition

[0743] The emotion engine receives emotional information entered by the user and recognizes those emotions.

[0744] The server dynamically adjusts prediction results and suggested countermeasures based on user emotion information obtained from the emotion engine.

[0745] 6. Prediction and Analysis

[0746] When a user inputs new litigation information and sentiment information, the server uses that information to predict the probability of winning the case using a pre-trained model.

[0747] Along with the predicted probability of winning, the server uses information from the emotion engine to suggest the most suitable course of action to the user. For example, it might suggest specific action plans such as "review the contract clauses" or "submit additional supporting documents."

[0748] Specific example

[0749] 1. Specific examples of data collection

[0750] For example, if a user is considering a "breach of contract lawsuit," they would enter the judge's name and information about past cases. The server would then retrieve similar lawsuit data from the past 10 years and the latest legal amendments from its database.

[0751] 2. Specific Examples of Data Preprocessing

[0752] The server preprocesses the retrieved data; for example, if there are missing values, it uses the average of similar historical data to fill them in. For non-numeric data, it converts the text to numbers.

[0753] 3. Specific Examples of Feature Extraction

[0754] If the type of lawsuit is "breach of contract," the server extracts features from past court data that influence the outcome of similar lawsuits (e.g., the content of the contract and the presence or absence of evidence).

[0755] 4. Specific Examples of Model Learning

[0756] The server builds a machine learning model using contract breach litigation data and evaluates its accuracy using cross-validation.

[0757] 5. Specific examples of emotion recognition

[0758] When a user inputs emotional information into the device, the emotion engine analyzes that information and recognizes emotional states such as "high stress" or "feeling at ease."

[0759] 6. Specific examples of predictions and proposed countermeasures

[0760] When a user provides new litigation and sentiment information, the server uses data from the sentiment engine to predict a "75% chance of winning" and suggests, for example, if the user is feeling stressed, to "consult with a lawyer in a relaxing environment" or "review contract clauses and submit additional evidence."

[0761] This system not only assists in decision-making when considering litigation, but also supports more appropriate and effective litigation preparation by providing countermeasures that take into account the user's emotional state.

[0762] The following describes the processing flow.

[0763] Step 1:

[0764] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information via their device.

[0765] Step 2:

[0766] The server receives input information from users and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[0767] Step 3:

[0768] The server cleanses the collected data, removing inaccurate and duplicate data.

[0769] Step 4:

[0770] The server identifies data with missing values ​​and uses statistical methods to impute those missing values ​​with the mean.

[0771] Step 5:

[0772] The server converts the data into a format that machine learning algorithms can easily process. Specifically, it converts text data into numerical data.

[0773] Step 6:

[0774] The server selects features from past litigation data that may influence the outcome of a lawsuit. Examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[0775] Step 7:

[0776] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[0777] Step 8:

[0778] The server splits the dataset into training and test data. This makes it easier to evaluate the generalization performance of the model.

[0779] Step 9:

[0780] The server uses the selected machine learning model to build a model based on the training data.

[0781] Step 10:

[0782] The server performs cross-validation and evaluates the accuracy of the model.

[0783] Step 11:

[0784] The server uses an emotion engine to recognize emotions based on user input. For example, if the user answers "anxious," the emotion engine processes that emotional state as data.

[0785] Step 12:

[0786] The emotion engine sends the recognized emotion information to the server, which then adjusts the prediction results and proposed countermeasures based on this information.

[0787] Step 13:

[0788] When a user inputs new litigation information and sentiment information, the server uses that information to predict the probability of winning the case using a pre-trained model.

[0789] Step 14:

[0790] The server presents the user with the most suitable course of action based on information from the emotion engine, along with the predicted probability of winning the case. For example, if the probability of winning is 75% and the user is experiencing high stress, the server will suggest action plans such as "reviewing the contract terms" and "submitting additional evidence," as well as "consulting with an expert in a relaxed environment."

[0791] Specific example

[0792] 1. Specific examples of data collection

[0793] A user considers filing a lawsuit for breach of contract and enters information such as the judge's name and details of past cases. The server then retrieves data on similar lawsuits from the past 10 years and the latest legal amendments from its database.

[0794] 2. Specific Examples of Data Preprocessing

[0795] The server preprocesses the retrieved data; for example, if there are missing values, it uses the average of similar historical data to fill them in. For non-numeric data, it converts the text to numbers.

[0796] 3. Specific Examples of Feature Extraction

[0797] If the type of lawsuit is "breach of contract," the server extracts features from past court data that influence the outcome of similar lawsuits (e.g., the content of the contract and the presence or absence of evidence).

[0798] 4. Specific Examples of Model Learning

[0799] The server builds a machine learning model using contract breach litigation data and evaluates its accuracy using cross-validation.

[0800] 5. Specific examples of emotion recognition

[0801] When a user inputs emotional information into their device, they select an emotion such as "anxiety," "anticipation," or "stress." The emotion engine then analyzes this information to recognize the user's emotional state.

[0802] 6. Specific examples of predictions and proposed countermeasures

[0803] Based on the newly provided litigation and emotional information from the user, the server predicts a "75% chance of winning" using data from the emotional engine. For example, if the user is feeling anxious, it suggests "revising the contract clauses and submitting additional evidence" as well as "consulting a psychological counselor."

[0804] This system not only assists in decision-making when considering litigation, but also supports more appropriate and effective litigation preparation by providing countermeasures that take into account the user's emotional state.

[0805] (Example 2)

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

[0807] Conventional litigation support systems have a problem in that they predict the probability of winning a lawsuit and suggest countermeasures without considering the user's emotional state, making it difficult for users to make informed decisions. Furthermore, the accuracy of predictions is also hampered by incomplete or redundant input data.

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

[0809] In this invention, the server includes means for collecting data from a historical database, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to the lawsuit, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, means for presenting the prediction results and proposed countermeasures, means for inputting and analyzing emotional information from the user, and means for dynamically adjusting the prediction results and proposed countermeasures based on the analyzed emotional information. This makes it possible to predict the probability of winning with high accuracy and present appropriate countermeasures that take into account the user's emotional state.

[0810] "Data collection" is the process of gathering necessary information from past databases.

[0811] "Data cleansing" is the process of removing inaccurate or duplicate data from collected data.

[0812] "Missing value imputation" is the process of filling in missing values ​​in a dataset with appropriate values.

[0813] "Feature extraction" is the process of selecting features from data that may influence the outcome of a lawsuit.

[0814] "Encoding" is the process of converting categorical data into numerical data.

[0815] A "machine learning model" is a collection of algorithms trained to make predictions and classifications based on data.

[0816] "Model training" is the process of training a machine learning model using collected data.

[0817] "Predicting the probability of winning a lawsuit" is the process of calculating the probability of winning a lawsuit using a trained machine learning model.

[0818] "Prediction result" refers to the output value calculated by the machine learning model.

[0819] "Presenting proposed solutions" means providing users with guidance on what to do based on the prediction results.

[0820] "Emotional information" refers to data that indicates the user's mental state.

[0821] "Emotional analysis" is the process of evaluating a user's mental state based on the emotional information they have entered.

[0822] "Dynamic adjustment" refers to changing the system's behavior and output in real time based on analyzed emotional information.

[0823] This invention relates to a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation. The system consists of a server, a user terminal, a database, and an emotion engine. The user terminal provides an interface for inputting litigation information and the user's emotions, while the server performs data collection, preprocessing, feature extraction, model training, prediction, and results presentation. The emotion engine recognizes the user's emotions and improves the system's performance.

[0824] Hardware and software to be used

[0825] Server: A server with high-performance computing capabilities is required. For example, a server equipped with an Intel processor would be used.

[0826] User terminal: This refers to a device used by the user to input data, such as a personal computer or smartphone. For example, devices running Windows or iOS are suitable.

[0827] Database: A database is needed to store past litigation information and legal data. A relational database such as MySQL or PostgreSQL will be used.

[0828] Emotion Engine: This software uses natural language processing (NLP) or emotion analysis engines to analyze user emotion information. Examples include open-source emotion analysis libraries such as NLTK and TextBlob.

[0829] Machine learning libraries: Machine learning libraries such as TensorFlow and Scikit-learn are used to build and train models.

[0830] Explanation of the process

[0831] Data collection

[0832] Users input information about the lawsuit (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information through their device. For example, if a user is considering a "breach of contract lawsuit," they would input the judge's name and information about past cases.

[0833] The server receives this input information and collects relevant data from its historical litigation database. It also collects information on legal amendments and recent case precedents from its up-to-date legal database. For example, it retrieves data on similar litigation from the past 10 years and information on recent legal amendments.

[0834] Data preprocessing

[0835] The server cleanses the collected data, removing inaccurate and duplicate entries. For example, it might delete duplicate records for the same case.

[0836] The server identifies data with missing values ​​and imputes them using statistical methods. For example, it might fill in missing values ​​with the mean of past data.

[0837] The server converts the data into a format that machine learning algorithms can easily process. For example, it encodes text data into categorical data and converts it into numerical data.

[0838] Feature extraction

[0839] The server selects features from past litigation data that may influence the outcome of a lawsuit. For example, in a "breach of contract" lawsuit, the content of the contract and the presence or absence of evidence are important features.

[0840] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data. For example, it assigns a unique numerical ID to a judge's name.

[0841] Model Learning

[0842] The server splits the dataset into training data and test data, and then builds a model based on the training data using the selected machine learning model. For example, it might split the dataset into 80% training data and 20% test data.

[0843] The server performs cross-validation to evaluate the model's accuracy. For example, it verifies the model's accuracy by performing k-fold cross-validation.

[0844] emotion recognition

[0845] The user inputs emotional information into the device. For example, they might input emotions such as "high stress" or "feeling relieved."

[0846] The emotion engine analyzes the input emotion information to identify the user's emotional state. For example, it uses natural language processing to analyze emotions from user input.

[0847] The server dynamically adjusts prediction results and suggested actions based on emotional information obtained from the emotion engine. For example, if the user is feeling stressed, a relaxation message will be added to the suggested actions.

[0848] Prediction and Analysis

[0849] When a user enters new litigation and sentiment information, the server uses a trained model to predict the probability of winning. For example, it might display "75% probability of winning this breach of contract lawsuit."

[0850] Based on information from the emotion engine, the server presents the user with the most suitable course of action. For example, it provides specific action plans such as "review the contract terms" or "submit additional supporting documents."

[0851] Specific example

[0852] If a user is considering a "breach of contract lawsuit," they enter information such as "Judge's name: X, Lawyer's name: Y, Summary of the lawsuit" into their device. The server receives this information and collects similar lawsuit data from its database of past lawsuits. Additionally, if the user enters "I am feeling stressed," the emotion engine analyzes this, and the server provides additional suggestions for countermeasures corresponding to the stress level.

[0853] This system supports decision-making in litigation and provides optimal solutions that take into account the user's emotional state, thereby assisting in effective litigation preparation.

[0854] Example of a prompt:

[0855] "I am considering a lawsuit for breach of contract. The judge's name is X, and my lawyer is Y. The details of the lawsuit are as follows... I am currently experiencing stress."

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

[0857] Step 1:

[0858] Data collection

[0859] Users input litigation information (e.g., type of lawsuit, judge's name, legal documents) and sentiment information through their device. An example of input might be "breach of contract lawsuit, Judge X, Lawyer Y".

[0860] The terminal sends the entered information to the server. At this time, the input information is sent in JSON format or similar.

[0861] The server receives the input information and collects relevant historical litigation data and current legal data from the database. For example, it extracts contract breach litigation data from the past 10 years.

[0862] Input: litigation information, sentiment information

[0863] Output: Past litigation data, legal data

[0864] Step 2:

[0865] Data preprocessing

[0866] The server cleanses the received data, removing inaccurate and duplicate entries. Specifically, this involves actions such as "deleting records with blank judge names" and "merging duplicate litigation data."

[0867] The server identifies missing values ​​and imputes them based on statistical methods. For example, "if past data for Judge Y is missing, it will impute it with the mean."

[0868] The server converts text data into numerical data. For example, it encodes "the judge's name" into a categorical ID.

[0869] Input: Collected litigation data, legal data

[0870] Output: Cleansed and imputed data

[0871] Step 3:

[0872] Feature extraction

[0873] The server extracts features that influence the outcome of a lawsuit. Specifically, it selects features such as "type of lawsuit," "judge's tendencies," and "lawyer's years of experience."

[0874] The server encodes categorical data into numerical data. For example, it converts "Judge X" to "Category ID 1".

[0875] Input: Preprocessed litigation data

[0876] Output: Feature data

[0877] Step 4:

[0878] Model Learning

[0879] The server splits the litigation data into training data and test data. Specifically, it uses "80% as training data and 20% as test data."

[0880] The server uses a selected machine learning model (e.g., Random Forest) to build a model based on the training data.

[0881] The server performs cross-validation to evaluate the model's accuracy. For example, it checks the model's accuracy using "k-fold cross-validation".

[0882] Input: Feature data

[0883] Output: Trained model, model accuracy evaluation results

[0884] Step 5:

[0885] emotion recognition

[0886] The user inputs emotional information into the device. For example, they might input information such as "Stress level: High" and "Sense of security: Low."

[0887] The emotion engine analyzes the input emotional information. Specifically, it uses natural language processing to determine that the user is "highly stressed."

[0888] The server dynamically adjusts prediction results and suggested actions based on emotional information obtained from the emotion engine. For example, if the user enters "high stress level," a relaxation message will be added.

[0889] Input: User sentiment information

[0890] Output: Analyzed sentiment data

[0891] Step 6:

[0892] Prediction and Analysis

[0893] When a user enters new litigation and sentiment information, the server uses a trained model to predict the probability of winning. Specifically, it will display something like, "75% probability of winning this breach of contract lawsuit."

[0894] Based on information from the emotion engine, the server presents the user with the most suitable course of action. Specific action plans might include suggestions such as "review the contract clauses" or "consult with a lawyer in a relaxed environment."

[0895] Input: New litigation information, analyzed sentiment data

[0896] Output: Probability of winning the case, proposed countermeasures

[0897] (Application Example 2)

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

[0899] While systems exist that predict the probability of winning a case and provide appropriate countermeasures based on past precedents and the latest legal information when considering litigation, few systems provide countermeasures that take into account the user's emotional state. Under high-stress conditions, users are less likely to make optimal decisions, resulting in inefficient litigation preparation. Furthermore, dynamically updating litigation information and providing timely advice tailored to the user's emotional state is also difficult. Solving these problems is the objective of this invention.

[0900] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for collecting data from past databases, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to the lawsuit, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, means for recognizing the user's emotional state, means for presenting countermeasures based on the emotional state, and means for providing new lawsuit information and dynamic countermeasures based on the emotional state. This makes it possible to predict the probability of winning with high accuracy based on past precedents and the latest legal information while taking the user's emotional state into consideration, and to provide prompt and appropriate advice.

[0901] definition statement

[0902] "Data collection" is the process of obtaining past case precedents, legal information, and user litigation information from a database.

[0903] "Data cleansing" is the process of removing inaccurate or duplicate data from collected data.

[0904] "Missing value imputation" is the process of filling in missing data based on the mean or existing data.

[0905] "Feature extraction" is a technique for selecting data that may influence the outcome of a lawsuit and converting it into a format that is easy to analyze.

[0906] "Encoding" is the process of converting categorical data into numerical data.

[0907] A "machine learning model" is an algorithm that performs predictions and classifications based on past data.

[0908] "Model learning" is the process of feeding data to a machine learning model to improve its prediction accuracy.

[0909] "Predicting the probability of winning a lawsuit" is the process of predicting the likelihood of winning a lawsuit as a numerical value.

[0910] "Emotion recognition" is a technology that recognizes a user's emotional state from the information they input.

[0911] "Presenting proposed solutions" is the process of providing specific action plans and advice tailored to the user's situation.

[0912] "Dynamic solution provision" refers to a technology that provides solutions in real time based on updated litigation information and emotional states.

[0913] Modes for carrying out the invention

[0914] System Configuration

[0915] The system for carrying out this invention consists of the following main components.

[0916] 1. Server: Performs data collection, cleansing, missing value imputation, feature extraction, encoding, machine learning model training, sentiment recognition, win probability prediction, and proposal of countermeasures.

[0917] 2. User terminal: Provides an interface for inputting litigation information and emotional state, and receiving prediction results and proposed countermeasures.

[0918] 3. Database: Stores past litigation data, legal documents, and the latest information on legal amendments.

[0919] 4. Emotion Engine: Analyzes the user's emotional state and provides data to improve the system's effectiveness.

[0920] Hardware and software to be used

[0921] Hardware: Computer servers, smartphones, network infrastructure

[0922] Software: Python, Pandas, Scikit-learn, emotion_recognition library, database management system

[0923] Program processing

[0924] Data Collection: The server collects necessary data from past litigation databases, user input, and the latest legal databases. This includes the type of litigation, judge information, and relevant legal documents.

[0925] Data cleansing and missing value imputation: The server cleanses the collected data, removing inaccurate and duplicate data. Furthermore, it imputates missing data using mean values ​​and other statistical methods.

[0926] Feature extraction and encoding: The server extracts key features relevant to the litigation and encodes categorical data into numerical data.

[0927] Machine learning model training: The server uses these features to train a machine learning model and evaluates the model's accuracy through cross-validation.

[0928] Emotion Recognition: The system receives emotional information input from the user's device and uses an emotion engine to identify the user's emotional state.

[0929] Predicting the probability of winning: Based on new litigation information and the user's emotional state, the server uses a model to predict the probability of winning.

[0930] Proposal of countermeasures: The server provides the user with the optimal countermeasures based on the prediction results and emotional state.

[0931] Specific example

[0932] For example, if a user is considering a lawsuit for breach of contract, they would input information such as the judge's name and details of past cases. Based on this information, the server would collect relevant data from its historical database and obtain the latest legal information. Next, the server would cleanse the data and impute any missing values. It would use a machine learning model to predict the probability of winning and an emotion engine to recognize the user's emotional state. As a result, the server would predict that there is a "75% chance of winning" and, if the user's emotional state indicates stress, would suggest a course of action such as "consulting with a lawyer in a relaxing environment."

[0933] Example of a prompt

[0934] User input:

[0935] "I am very worried about this lawsuit."

[0936] Emotion recognition prompt:

[0937] "Based on this text, identify the user's emotions, recognize their emotional state (e.g., high stress, feeling at ease), and output the results."

[0938] In this way, the system can provide more appropriate advice based on the user's emotional state and assist in preparing for litigation.

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

[0940] Program processing steps

[0941] Step 1:

[0942] Data collection

[0943] Input: The user enters litigation information (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information into the device.

[0944] Specific operation: The user uses their device to enter litigation-related information into forms and fields. This information is then sent from the device to the server.

[0945] Data processing / calculation: The server uses the received input information as a database query to collect historical litigation data and the latest legal information from the database.

[0946] Output: A set of collected litigation data and legal documents.

[0947] Step 2:

[0948] Data cleansing and missing value imputation

[0949] Input: The dataset collected in Step 1.

[0950] Specific operation: The server analyzes the collected dataset and removes redundant or inaccurate data. Next, it identifies missing data and fills it in using statistical methods (e.g., mean imputation).

[0951] Data processing / calculations: Deleting duplicate data, identifying and imputing missing values.

[0952] Output: Cleansed dataset with no missing values.

[0953] Step 3:

[0954] Feature extraction and encoding

[0955] Input: The dataset cleansed in Step 2.

[0956] Specific operation: The server selects features that may influence the outcome of a lawsuit (e.g., the type of lawsuit and the judge's ruling tendencies). It also encodes categorical data (e.g., the judge's name and the type of lawsuit) into numerical data.

[0957] Data processing / calculations: Feature extraction, numerical conversion of categorical data.

[0958] Output: A dataset with extracted and encoded features.

[0959] Step 4:

[0960] Training machine learning models

[0961] Input: The feature dataset created in Step 3.

[0962] Specific operation: The server splits the dataset into training and test data, and builds a model based on the training data using a selected machine learning model (e.g., Random Forest). Cross-validation is performed to evaluate the accuracy of the model.

[0963] Data processing / computation: Data splitting, model training, and evaluation using cross-validation.

[0964] Output: Trained machine learning model.

[0965] Step 5:

[0966] emotion recognition

[0967] Input: Sentimental information (text data) from the user's terminal.

[0968] Specific operation: The server receives emotional information entered by the user on the device (for example, "I feel very uneasy about this lawsuit"). The server uses the emotion_recognition library to analyze the entered text and recognize the emotional state.

[0969] Data processing / calculation: Analysis of text data, recognition of emotional states.

[0970] Output: Recognized emotional state (e.g., "anxiety").

[0971] Step 6:

[0972] Prediction of the probability of winning the case

[0973] Input: Trained model, Step 3 feature data, new litigation information, Step 5 sentiment state.

[0974] Specific operation: The server uses a pre-trained model to predict the probability of winning the case, taking into account new litigation information and emotional states.

[0975] Data processing / calculation: Inputting feature data into the model, calculating the probability of winning.

[0976] Output: Predicted probability of winning the case.

[0977] Step 7:

[0978] Presentation of countermeasures

[0979] Input: Predicted probability of winning the case, emotional state.

[0980] Specific operation: The server generates optimal countermeasures based on the predicted probability of winning the case and the user's emotional state. For example, if the probability of winning is high and the user is feeling stressed, it will create specific advice such as "consult with a lawyer in a relaxing environment."

[0981] Data processing / calculation: Analysis of prediction results and emotional states, generation of countermeasures.

[0982] Output: Proposed countermeasures as notifications to the user's terminal.

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

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

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

[0986] [Third Embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0999] System Configuration

[1000] This invention is a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation, and consists of a server, a user terminal, and a database. The user terminal provides an interface for inputting litigation information, and the server performs data collection, preprocessing, feature extraction, model training, prediction, and result presentation.

[1001] System program processing

[1002] 1. Data Collection

[1003] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) via their device.

[1004] The server receives this input information and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[1005] 2. Data preprocessing

[1006] The server cleanses the collected data, removing inaccurate and duplicate data.

[1007] The server identifies data with missing values ​​and imputes them. For example, it might use statistical methods to impute them with the mean, or predict them based on past trends.

[1008] The server converts the data into a format that is easy for machine learning algorithms to process, and converts text data into numerical data.

[1009] 3. Feature Extraction

[1010] The server selects features from past litigation data that may influence the outcome of a lawsuit. Specific examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[1011] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[1012] 4. Model Learning

[1013] The server splits the dataset into training data and test data, and then builds a model based on the training data using the selected machine learning model.

[1014] The server performs cross-validation and evaluates the accuracy of the model.

[1015] 5. Prediction and Analysis

[1016] When a user enters new litigation information, the server uses a pre-trained model to predict the probability of winning the case based on that information.

[1017] Along with the predicted probability of winning the case, the server presents the user with specific countermeasures. For example, it might suggest concrete action plans such as "review the contract clauses" or "submit additional supporting documents."

[1018] Specific example

[1019] 1. Specific examples of data collection

[1020] For example, if a user is considering a "breach of contract lawsuit," they would enter the judge's name and information about past cases. The server would then retrieve similar lawsuit data from the past 10 years and the latest legal amendments from its database.

[1021] 2. Specific Examples of Data Preprocessing

[1022] The server preprocesses the retrieved data; for example, if there are missing values, it uses the average of similar historical data to fill them in. For non-numeric data, it converts the text to numbers.

[1023] 3. Specific Examples of Feature Extraction

[1024] If the type of lawsuit is "breach of contract," the server extracts features from past court data that influence the outcome of similar lawsuits (e.g., the content of the contract and the presence or absence of evidence).

[1025] 4. Specific Examples of Model Learning

[1026] The server builds a machine learning model using contract breach litigation data and evaluates its accuracy using cross-validation.

[1027] 5. Specific examples of predictions and proposed countermeasures

[1028] When a user provides new litigation information, the server predicts a "75% chance of winning" and suggests specific countermeasures such as "revising the contract clauses and submitting additional evidence."

[1029] This system assists decision-making when considering litigation and provides support to help users proceed with litigation from a more advantageous position.

[1030] The following describes the processing flow.

[1031] Step 1:

[1032] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) via their device.

[1033] Step 2:

[1034] The server receives user input information and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[1035] Step 3:

[1036] The server cleanses the collected data, removing inaccurate and duplicate data.

[1037] Step 4:

[1038] The server identifies data with missing values ​​and imputes them using statistical methods. For example, it might use the mean to impute them.

[1039] Step 5:

[1040] The server converts the data into a format that machine learning algorithms can easily process. Specifically, it converts text data into numerical data.

[1041] Step 6:

[1042] The server selects features from past litigation data that may influence the outcome of a lawsuit. Examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[1043] Step 7:

[1044] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[1045] Step 8:

[1046] The server splits the dataset into training and test data. This makes it easier to evaluate the generalization performance of the model.

[1047] Step 9:

[1048] The server uses the selected machine learning model to build a model based on the training data.

[1049] Step 10:

[1050] The server performs cross-validation and evaluates the accuracy of the model.

[1051] Step 11:

[1052] When a user enters new litigation information, the server uses a pre-trained model to predict the probability of winning the case based on that information.

[1053] Step 12:

[1054] The server presents the user with a predicted probability of winning the case, along with specific countermeasures. For example, it might suggest concrete action plans such as "review the contract clauses" or "submit additional supporting documents."

[1055] (Example 1)

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

[1057] Conventional litigation support systems struggle to provide reliable data analysis and concrete strategies for users to predict the probability of winning a lawsuit. In particular, traditional methods are inefficient at processing inaccurate and duplicate data, imputing missing data, extracting and encoding features, and evaluating the accuracy of machine learning models, resulting in insufficient support for user decision-making.

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

[1059] In this invention, the server includes means for dynamically collecting information from a past database based on litigation information entered by the user; means for cleansing the collected information, removing inaccurate and duplicate data, and supplementing missing data; means for selecting features that affect the outcome of the litigation and encoding categorical data into numerical data; means for building a model based on training data using a machine learning model and evaluating the accuracy of the model by cross-validation; means for predicting the probability of winning from newly entered litigation information based on the trained model; and means for presenting specific countermeasures along with the prediction results. This makes it possible to predict the probability of winning with high accuracy and to present specific and effective litigation countermeasures.

[1060] A "user" is an individual or organization that uses the system to input litigation information and receives predictions of the probability of winning and suggestions for countermeasures.

[1061] "Terminal" refers to a device used by a user to input litigation information, and includes personal computers, smartphones, tablets, etc.

[1062] A "server" is a central processing unit that processes information entered by users and performs data collection, data preprocessing, feature extraction, model training, prediction, and result presentation.

[1063] A "database" is an information storage system used to manage and retrieve past litigation data and the latest legal information.

[1064] "Data cleansing" is the process of removing inaccurate or duplicate data from collected information to improve data consistency and reliability.

[1065] "Missing data imputation" is the process of filling in missing values ​​in a dataset using statistical methods or other data points.

[1066] "Feature extraction" is a process used to identify important data items that may influence the outcome of a lawsuit and to analyze litigation information.

[1067] "Category data encoding" is the process of converting text or categorical data into numerical data that can be processed by machine learning.

[1068] A "machine learning model" is an algorithm that is trained using historical data and then used to make predictions and classifications on new data.

[1069] Cross-validation is a technique for evaluating the generality and accuracy of a model by dividing the training data and performing multiple training and evaluation iterations.

[1070] "Predicting the probability of winning a case" is the process of using a pre-trained model to numerically calculate the likelihood of winning a case based on new litigation information.

[1071] "Presenting countermeasures" is the process of proposing specific actions and strategies that users should take based on the predicted probability of winning the case.

[1072] The following describes in detail the embodiments for which this invention is specifically implemented.

[1073] System Configuration

[1074] This invention is a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation, and consists of a server, a user terminal, and a database. The user terminal provides an interface for inputting litigation information, and the server performs data collection, preprocessing, feature extraction, model training, prediction, and result presentation.

[1075] Hardware and software to be used

[1076] 1. Hardware

[1077] User terminal: A device such as a personal computer, smartphone, or tablet.

[1078] Server: A central processing unit for data processing. A server equipped with a high-performance processor.

[1079] Database: A storage system for managing litigation data. Specifically, MySQL will be used.

[1080] 2. Software

[1081] Data cleansing and imputation: Using the Python Pandas library.

[1082] Feature extraction and encoding: Use CountVectorizer and One-Hot encoding from the Scikit-learn library.

[1083] Model training and accuracy evaluation: Use RandomForestClassifier and cross-validation from the Scikit-learn library.

[1084] Program processing

[1085] 1. Data Collection

[1086] The user enters litigation information through their device. This information includes the type of lawsuit, the judge's information, and relevant legal documents.

[1087] The server receives input information in real time and collects historical litigation data and the latest legal information. Specifically, it uses the Flask framework in Python to receive data and retrieves relevant information from a MySQL database.

[1088] 2. Data preprocessing

[1089] The server cleanses the collected data, removing inaccurate and duplicate entries. This is done using the Python Pandas library.

[1090] The server will impute missing data. Missing values ​​will be filled in using statistical methods, specifically by calculating the mean using the Pandas library.

[1091] The server converts the data format into one that is easily processed by machine learning algorithms. Text data is converted to numerical data using CountVectorizer.

[1092] 3. Feature Extraction

[1093] The server extracts features that influence the outcome of the lawsuit. This process uses the Scikit-learn library to select features such as the type of lawsuit, the judge's ruling tendencies, and the lawyer's experience.

[1094] The server encodes categorical data into numerical data. One-hot encoding is used to convert categorical data into numerical data.

[1095] 4. Model Learning

[1096] The server splits the dataset into training and test data and builds a model using the RandomForestClassifier from the Scikit-learn library.

[1097] The server performs cross-validation to evaluate the model's accuracy. This verifies the model's generality and accuracy.

[1098] 5. Prediction and Analysis

[1099] When a user enters new litigation information, the server uses a pre-trained model to predict the probability of winning the case.

[1100] Based on the prediction results, the server presents the user with specific countermeasures. For example, in the case of a breach of contract lawsuit, it might display a "75% chance of winning" and suggest "revise the contract clauses and submit additional supporting documents."

[1101] Specific example

[1102] 1. Example of data collection

[1103] The user considers filing a "breach of contract lawsuit" and enters the judge's name and details of the lawsuit into their terminal. The server receives this information and collects similar lawsuit data from its MySQL database.

[1104] 2. Examples of data preprocessing

[1105] The server cleanses the collected data using the Pandas library and imputes missing data. For example, it might use the mean of similar historical data to impute missing values.

[1106] 3. Examples of Feature Extraction

[1107] If the type of lawsuit is "breach of contract," the server extracts features such as the content of the contract and the presence or absence of evidence from past court data.

[1108] 4. Examples of Model Learning

[1109] The server uses contract breach litigation data to build a machine learning model with RandomForestClassifier and performs cross-validation.

[1110] 5. Examples of Predictions and Proposed Countermeasures

[1111] When a user enters new litigation information, the server predicts a "75% chance of winning" and suggests specific countermeasures such as "re-examining the contract clauses" or "submitting additional evidence."

[1112] Example of a prompt

[1113] "We are considering filing a lawsuit for breach of contract. Based on past data from similar lawsuits and the latest legal information, please predict the probability of winning and propose specific countermeasures."

[1114] This system will enable effective support for users' decision-making when considering litigation.

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

[1116] Step 1:

[1117] The user enters litigation information via their device. This input includes the type of litigation, judge information, and relevant legal documents. For example, if the user is considering a "breach of contract lawsuit," they would enter the judge's name and details of the lawsuit. Input: Litigation information (e.g., type of litigation, judge's name, relevant legal documents). Output: Litigation information sent to the endpoint.

[1118] Step 2:

[1119] The server receives litigation information submitted by users in real time. Based on the received information, it executes queries to collect relevant information from historical litigation databases and current legal databases. Specifically, it uses the Flask framework in Python to receive data and retrieve the necessary information from a MySQL database. Input: Litigation information submitted to the endpoint. Output: Historical litigation data and current legal information.

[1120] Step 3:

[1121] The server cleanses the collected data. Specifically, it uses the Pandas library to remove inaccurate and duplicate data. Next, it imputes missing data and converts text data to numerical data. The mean of similar historical data is used to impute missing values. For example, the mean of similar historical litigation data is used to impute missing values. Input: Historical litigation data and recent legal information. Output: Preprocessed dataset.

[1122] Step 4:

[1123] The server extracts features from a preprocessed dataset and encodes categorical data into numerical data. The Scikit-learn library is used for feature extraction, selecting important features (e.g., type of lawsuit, judge's ruling tendencies, lawyer's experience). Categorical data is converted to numerical data using one-hot encoding. Input: Preprocessed dataset. Output: Feature-extracted and encoded dataset.

[1124] Step 5:

[1125] The server trains a machine learning model using a feature-extracted dataset. It splits the dataset into training and test data, and builds and trains the model using the RandomForestClassifier from the Scikit-learn library. The model's accuracy is evaluated using cross-validation. Input: Feature-extracted and encoded dataset. Output: Trained machine learning model and its evaluation results.

[1126] Step 6:

[1127] When a user enters new litigation information, the server predicts the probability of winning based on a trained model. The entered litigation information is fed into the model, and the prediction result is calculated. For example, when new litigation information is entered, "75% probability of winning" is displayed. Input: New litigation information. Output: Predicted probability of winning result.

[1128] Step 7:

[1129] The server presents the user with specific countermeasures based on the prediction results. For example, it might suggest concrete action plans such as "revise the contract clauses and submit additional supporting documents." This allows the user to proceed with the lawsuit from a more advantageous position. Input: Predicted probability of winning. Output: Specific countermeasures.

[1130] Through the processing steps described above, this system provides users with the necessary information analysis and countermeasures when proceeding with litigation, thereby supporting their decision-making.

[1131] (Application Example 1)

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

[1133] Conventional litigation support systems have suffered from insufficient prediction and countermeasures based on past precedents and legal amendments. As a result, users have difficulty making decisions when considering litigation, and risk management is not adequately implemented. Furthermore, there was no means to dynamically analyze the information users entered regarding legal issues and appropriately present specific countermeasures, thus requiring a swift and accurate response.

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

[1135] In this invention, the server includes means for collecting data from a historical database, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to the lawsuit, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, means for receiving input of legal issues from users, visualizing and displaying the results, and means for dynamically generating and presenting specific countermeasures. This enables dynamic analysis when a user inputs a legal issue, allowing for appropriate prediction of the probability of winning and presentation of specific countermeasures.

[1136] A "historical database" is a data storage system that preserves past precedents and legal document information related to litigation.

[1137] "Means of data collection" refers to techniques or methods for extracting necessary data from specific sources and storing it in a database.

[1138] "Data cleansing techniques" are techniques or methods for removing inaccurate or duplicate data in order to improve data quality.

[1139] "Missing value imputation" is the process of appropriately filling in missing data present in a portion of a dataset using statistical methods or inference.

[1140] "Means for extracting features relevant to litigation" refers to techniques or methods for selecting important attributes or elements that influence the outcome of litigation.

[1141] "Encoding means" refers to techniques or methods that convert categorical data into numerical data that can be processed by machine learning algorithms.

[1142] A "machine learning model" is a mathematical algorithm or statistical model that learns patterns and trends based on training data to perform predictions and classifications.

[1143] "Means of building and training" refers to techniques or methods for creating a model using training data and then optimizing its performance.

[1144] "Methods for predicting the probability of winning a case" refer to techniques or methods for probabilistically evaluating the outcome of a lawsuit based on a model.

[1145] "Means of receiving input on legal issues" refers to a technology or method for incorporating legal information provided by users into a system through an interface.

[1146] "Means of visualizing and displaying results" refers to techniques or methods for presenting data or prediction results to users in a visual format such as graphs or charts.

[1147] "Means for dynamically generating and presenting specific countermeasures" refers to a technology or method that generates and proposes actionable countermeasures in real time based on user input information.

[1148] This invention relates to a "corporate compliance monitoring application" that enables companies to anticipate legal issues in advance and take concrete countermeasures. This system consists of a server, user terminals, and a database.

[1149] System Configuration

[1150] The server uses hardware and software to perform the following functions:

[1151] For data collection and cleansing, we use database management systems (MySQL, PostgreSQL) and data analysis libraries (Pandas).

[1152] Feature extraction and encoding will be performed using the machine learning library (Scikit-learn).

[1153] Random Forest is used to build and train machine learning models.

[1154] The user terminal provides an interface for legal personnel to input information on legal issues and visually displays predicted results and proposed solutions from the server. A web browser or mobile application is used for the graphical user interface (GUI).

[1155] The database stores past case precedents and information on legal amendments, and is used by the server to dynamically search and extract the necessary data.

[1156] System processing

[1157] 1. Data collection:

[1158] The server receives information about legal issues sent from user terminals and collects relevant past case data and the latest legal amendment information from its database.

[1159] 2. Data preprocessing:

[1160] The server cleanses the collected data, removing inaccurate and duplicate data. Furthermore, it imputes missing values ​​and encodes categorical data into numerical data.

[1161] 3. Feature extraction and model training:

[1162] The server extracts features relevant to the lawsuit and builds a machine learning model based on historical data. The model's accuracy is evaluated using cross-validation.

[1163] 4. Predictions and proposed countermeasures:

[1164] When a new legal issue is entered by a user, the server predicts the probability of winning the case based on its model and dynamically generates and presents specific countermeasures. The prediction results and countermeasures are displayed visually on the user's terminal.

[1165] Program Processing Description

[1166] The server first receives information about legal issues and collects relevant data from historical databases. During the data collection process, a database management system (MySQL, PostgreSQL) is used to search for and extract the necessary data. Subsequently, the Pandas data analysis library is used to cleanse the data and impute missing values.

[1167] Next, the server extracts features related to the lawsuit from the collected data and encodes them into numerical data. Scikit-learn is used for this process. The Random Forest algorithm is employed for model construction and training, and the model's accuracy is evaluated by performing cross-validation.

[1168] When a user enters a new legal issue, the server predicts the probability of winning based on a trained model and displays this visually on the user's terminal. In addition, it dynamically generates proposed solutions and presents the user with a concrete action plan. This allows the user to take quick and appropriate action.

[1169] Specific example

[1170] For example, if a user is considering a "breach of contract lawsuit," they enter the judge's name and information about past cases. The server then retrieves data on similar lawsuits from the past 10 years and the latest legal amendments from its database and processes it. As a result, it displays a "75% chance of winning" and suggests countermeasures such as "reviewing the contract clauses and submitting additional evidence."

[1171] An example of a prompt message for a generative AI model is: "Build a model to predict the probability of winning a current legal issue based on past case data collected by a compliance monitoring application. Use features such as the type of legal issue, judge information, and legal documents to predict the probability of winning and create a prompt message that suggests specific countermeasures."

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

[1173] Step 1:

[1174] Data collection

[1175] The server receives information about the legal issue entered by the user (e.g., type of lawsuit, judge information, relevant documents). Based on this input, the server collects relevant case law data and the latest legal amendment information from its historical database.

[1176] Input: Information on legal issues

[1177] Output: Collected historical case law data and information on legal amendments.

[1178] Specifically, the server uses a database management system (MySQL, PostgreSQL) to query and retrieve the relevant data. For example, it might collect data on contract breaches over the past 10 years or information on the latest legal changes.

[1179] Step 2:

[1180] Data preprocessing

[1181] The server cleanses the collected data, removing inaccurate and duplicate data. If the collected data contains missing values, statistical methods are used to impute them.

[1182] Input: Collected historical case law data and information on legal amendments.

[1183] Output: Cleansed and imputed data

[1184] Specifically, the data is preprocessed using the Pandas data analysis library. Inaccurate and duplicate data are removed, and missing values ​​are imputed by predicting them from the mean or historical trends.

[1185] Step 3:

[1186] Feature extraction and encoding

[1187] The server extracts features from the cleansed data that could potentially influence the outcome of the lawsuit and encodes categorical data into numerical data.

[1188] Input: Cleansed data

[1189] Output: Data with extracted and encoded features

[1190] Specifically, the Scikit-learn library is used to quantify features such as the type of lawsuit, the judge's tendencies, and the content of legal documents. Categorical data is converted to numerical values ​​using LabelEncoder.

[1191] Step 4:

[1192] Model Learning

[1193] The server builds a machine learning model based on the data from which features have been extracted and encoded, and then trains it using the training data. After training, cross-validation is performed to evaluate the accuracy of the model.

[1194] Input: Data from which features have been extracted and encoded.

[1195] Output: Trained machine learning model

[1196] The server builds a model using the RandomForest algorithm from the Scikit-learn library, splits the data into training and test sets, and trains the model. Cross-validation is used to evaluate the model's accuracy and select the optimal model.

[1197] Step 5:

[1198] Predictions and proposed countermeasures

[1199] When a user inputs information about a new legal issue, the server predicts the probability of winning based on a trained model. It visualizes the prediction and displays it on the user's terminal, dynamically generating and proposing specific countermeasures.

[1200] Input: Information on new legal issues

[1201] Output: Predicted probability of winning the case and specific countermeasures.

[1202] Specifically, the server inputs data on new legal issues into a pre-trained model and obtains a predicted probability of winning. It then uses visualization tools to display the results in graphs and charts and presents specific countermeasures (e.g., reviewing contract clauses and submitting additional evidence).

[1203] Examples of prompts for a generative AI model:

[1204] "Based on past case data collected by a compliance monitoring application, we will build a model to predict the probability of winning current legal issues. Using features such as the type of legal issue, judge information, and legal documents, we will predict the probability of winning and create prompt messages suggesting specific countermeasures."

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

[1206] System Configuration

[1207] This invention relates to a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation, and consists of a server, a user terminal, a database, and an emotion engine. The user terminal provides an interface for inputting litigation information and the user's emotions, the server collects data, preprocesses it, extracts features, trains the model, makes predictions, and presents results, and the emotion engine recognizes the user's emotions and improves the system's performance.

[1208] System program processing

[1209] 1. Data Collection

[1210] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information via their device.

[1211] The server receives this input information and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[1212] 2. Data preprocessing

[1213] The server cleanses the collected data, removing inaccurate and duplicate data.

[1214] The server identifies data with missing values ​​and imputes them. For example, it might use statistical methods to impute them with the mean.

[1215] The server converts the data into a format that is easy for machine learning algorithms to process, and converts text data into numerical data.

[1216] 3. Feature Extraction

[1217] The server selects features from past litigation data that may influence the outcome of a lawsuit. Specific examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[1218] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[1219] 4. Model Learning

[1220] The server splits the dataset into training data and test data, and then builds a model based on the training data using the selected machine learning model.

[1221] The server performs cross-validation and evaluates the accuracy of the model.

[1222] 5. Emotion recognition

[1223] The emotion engine receives emotional information entered by the user and recognizes those emotions.

[1224] The server dynamically adjusts prediction results and suggested countermeasures based on user emotion information obtained from the emotion engine.

[1225] 6. Prediction and Analysis

[1226] When a user inputs new litigation information and sentiment information, the server uses that information to predict the probability of winning the case using a pre-trained model.

[1227] Along with the predicted probability of winning, the server uses information from the emotion engine to suggest the most suitable course of action to the user. For example, it might suggest specific action plans such as "review the contract clauses" or "submit additional supporting documents."

[1228] Specific example

[1229] 1. Specific examples of data collection

[1230] For example, if a user is considering a "breach of contract lawsuit," they would enter the judge's name and information about past cases. The server would then retrieve similar lawsuit data from the past 10 years and the latest legal amendments from its database.

[1231] 2. Specific Examples of Data Preprocessing

[1232] The server preprocesses the retrieved data; for example, if there are missing values, it uses the average of similar historical data to fill them in. For non-numeric data, it converts the text to numbers.

[1233] 3. Specific Examples of Feature Extraction

[1234] If the type of lawsuit is "breach of contract," the server extracts features from past court data that influence the outcome of similar lawsuits (e.g., the content of the contract and the presence or absence of evidence).

[1235] 4. Specific Examples of Model Learning

[1236] The server builds a machine learning model using contract breach litigation data and evaluates its accuracy using cross-validation.

[1237] 5. Specific examples of emotion recognition

[1238] When a user inputs emotional information into the device, the emotion engine analyzes that information and recognizes emotional states such as "high stress" or "feeling at ease."

[1239] 6. Specific examples of predictions and proposed countermeasures

[1240] When a user provides new litigation and sentiment information, the server uses data from the sentiment engine to predict a "75% chance of winning" and suggests, for example, if the user is feeling stressed, to "consult with a lawyer in a relaxing environment" or "review contract clauses and submit additional evidence."

[1241] This system not only assists in decision-making when considering litigation, but also supports more appropriate and effective litigation preparation by providing countermeasures that take into account the user's emotional state.

[1242] The following describes the processing flow.

[1243] Step 1:

[1244] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information via their device.

[1245] Step 2:

[1246] The server receives input information from users and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[1247] Step 3:

[1248] The server cleanses the collected data, removing inaccurate and duplicate data.

[1249] Step 4:

[1250] The server identifies data with missing values ​​and uses statistical methods to impute those missing values ​​with the mean.

[1251] Step 5:

[1252] The server converts the data into a format that machine learning algorithms can easily process. Specifically, it converts text data into numerical data.

[1253] Step 6:

[1254] The server selects features from past litigation data that may influence the outcome of a lawsuit. Examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[1255] Step 7:

[1256] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[1257] Step 8:

[1258] The server splits the dataset into training and test data. This makes it easier to evaluate the generalization performance of the model.

[1259] Step 9:

[1260] The server uses the selected machine learning model to build a model based on the training data.

[1261] Step 10:

[1262] The server performs cross-validation and evaluates the accuracy of the model.

[1263] Step 11:

[1264] The server uses an emotion engine to recognize emotions based on user input. For example, if the user answers "anxious," the emotion engine processes that emotional state as data.

[1265] Step 12:

[1266] The emotion engine sends the recognized emotion information to the server, which then adjusts the prediction results and proposed countermeasures based on this information.

[1267] Step 13:

[1268] When a user inputs new litigation information and sentiment information, the server uses that information to predict the probability of winning the case using a pre-trained model.

[1269] Step 14:

[1270] The server presents the user with the most suitable course of action based on information from the emotion engine, along with the predicted probability of winning the case. For example, if the probability of winning is 75% and the user is experiencing high stress, the server will suggest action plans such as "reviewing the contract terms" and "submitting additional evidence," as well as "consulting with an expert in a relaxed environment."

[1271] Specific example

[1272] 1. Specific examples of data collection

[1273] A user considers filing a lawsuit for breach of contract and enters information such as the judge's name and details of past cases. The server then retrieves data on similar lawsuits from the past 10 years and the latest legal amendments from its database.

[1274] 2. Specific Examples of Data Preprocessing

[1275] The server preprocesses the retrieved data; for example, if there are missing values, it uses the average of similar historical data to fill them in. For non-numeric data, it converts the text to numbers.

[1276] 3. Specific Examples of Feature Extraction

[1277] If the type of lawsuit is "breach of contract," the server extracts features from past court data that influence the outcome of similar lawsuits (e.g., the content of the contract and the presence or absence of evidence).

[1278] 4. Specific Examples of Model Learning

[1279] The server builds a machine learning model using contract breach litigation data and evaluates its accuracy using cross-validation.

[1280] 5. Specific examples of emotion recognition

[1281] When a user inputs emotional information into their device, they select an emotion such as "anxiety," "anticipation," or "stress." The emotion engine then analyzes this information to recognize the user's emotional state.

[1282] 6. Specific examples of predictions and proposed countermeasures

[1283] Based on the newly provided litigation and emotional information from the user, the server predicts a "75% chance of winning" using data from the emotional engine. For example, if the user is feeling anxious, it suggests "revising the contract clauses and submitting additional evidence" as well as "consulting a psychological counselor."

[1284] This system not only assists in decision-making when considering litigation, but also supports more appropriate and effective litigation preparation by providing countermeasures that take into account the user's emotional state.

[1285] (Example 2)

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

[1287] Conventional litigation support systems have a problem in that they predict the probability of winning a lawsuit and suggest countermeasures without considering the user's emotional state, making it difficult for users to make informed decisions. Furthermore, the accuracy of predictions is also hampered by incomplete or redundant input data.

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

[1289] In this invention, the server includes means for collecting data from a historical database, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to the lawsuit, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, means for presenting the prediction results and proposed countermeasures, means for inputting and analyzing emotional information from the user, and means for dynamically adjusting the prediction results and proposed countermeasures based on the analyzed emotional information. This makes it possible to predict the probability of winning with high accuracy and present appropriate countermeasures that take into account the user's emotional state.

[1290] "Data collection" is the process of gathering necessary information from past databases.

[1291] "Data cleansing" is the process of removing inaccurate or duplicate data from collected data.

[1292] "Missing value imputation" is the process of filling in missing values ​​in a dataset with appropriate values.

[1293] "Feature extraction" is the process of selecting features from data that may influence the outcome of a lawsuit.

[1294] "Encoding" is the process of converting categorical data into numerical data.

[1295] A "machine learning model" is a collection of algorithms trained to make predictions and classifications based on data.

[1296] "Model training" is the process of training a machine learning model using collected data.

[1297] "Predicting the probability of winning a lawsuit" is the process of calculating the probability of winning a lawsuit using a trained machine learning model.

[1298] "Prediction result" refers to the output value calculated by the machine learning model.

[1299] "Presenting proposed solutions" means providing users with guidance on what to do based on the prediction results.

[1300] "Emotional information" refers to data that indicates the user's mental state.

[1301] "Emotional analysis" is the process of evaluating a user's mental state based on the emotional information they have entered.

[1302] "Dynamic adjustment" refers to changing the system's behavior and output in real time based on analyzed emotional information.

[1303] This invention relates to a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation. The system consists of a server, a user terminal, a database, and an emotion engine. The user terminal provides an interface for inputting litigation information and the user's emotions, while the server performs data collection, preprocessing, feature extraction, model training, prediction, and results presentation. The emotion engine recognizes the user's emotions and improves the system's performance.

[1304] Hardware and software to be used

[1305] Server: A server with high-performance computing capabilities is required. For example, a server equipped with an Intel processor would be used.

[1306] User terminal: This refers to a device used by the user to input data, such as a personal computer or smartphone. For example, devices running Windows or iOS are suitable.

[1307] Database: A database is needed to store past litigation information and legal data. A relational database such as MySQL or PostgreSQL will be used.

[1308] Emotion Engine: This software uses natural language processing (NLP) or emotion analysis engines to analyze user emotion information. Examples include open-source emotion analysis libraries such as NLTK and TextBlob.

[1309] Machine learning libraries: Machine learning libraries such as TensorFlow and Scikit-learn are used to build and train models.

[1310] Explanation of the process

[1311] Data collection

[1312] Users input information about the lawsuit (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information through their device. For example, if a user is considering a "breach of contract lawsuit," they would input the judge's name and information about past cases.

[1313] The server receives this input information and collects relevant data from its historical litigation database. It also collects information on legal amendments and recent case precedents from its up-to-date legal database. For example, it retrieves data on similar litigation from the past 10 years and information on recent legal amendments.

[1314] Data preprocessing

[1315] The server cleanses the collected data, removing inaccurate and duplicate entries. For example, it might delete duplicate records for the same case.

[1316] The server identifies data with missing values ​​and imputes them using statistical methods. For example, it might fill in missing values ​​with the mean of past data.

[1317] The server converts the data into a format that machine learning algorithms can easily process. For example, it encodes text data into categorical data and converts it into numerical data.

[1318] Feature extraction

[1319] The server selects features from past litigation data that may influence the outcome of a lawsuit. For example, in a "breach of contract" lawsuit, the content of the contract and the presence or absence of evidence are important features.

[1320] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data. For example, it assigns a unique numerical ID to a judge's name.

[1321] Model Learning

[1322] The server splits the dataset into training data and test data, and then builds a model based on the training data using the selected machine learning model. For example, it might split the dataset into 80% training data and 20% test data.

[1323] The server performs cross-validation to evaluate the model's accuracy. For example, it verifies the model's accuracy by performing k-fold cross-validation.

[1324] emotion recognition

[1325] The user inputs emotional information into the device. For example, they might input emotions such as "high stress" or "feeling relieved."

[1326] The emotion engine analyzes the input emotion information to identify the user's emotional state. For example, it uses natural language processing to analyze emotions from user input.

[1327] The server dynamically adjusts prediction results and suggested actions based on emotional information obtained from the emotion engine. For example, if the user is feeling stressed, a relaxation message will be added to the suggested actions.

[1328] Prediction and Analysis

[1329] When a user enters new litigation and sentiment information, the server uses a trained model to predict the probability of winning. For example, it might display "75% probability of winning this breach of contract lawsuit."

[1330] Based on information from the emotion engine, the server presents the user with the most suitable course of action. For example, it provides specific action plans such as "review the contract terms" or "submit additional supporting documents."

[1331] Specific example

[1332] If a user is considering a "breach of contract lawsuit," they enter information such as "Judge's name: X, Lawyer's name: Y, Summary of the lawsuit" into their device. The server receives this information and collects similar lawsuit data from its database of past lawsuits. Additionally, if the user enters "I am feeling stressed," the emotion engine analyzes this, and the server provides additional suggestions for countermeasures corresponding to the stress level.

[1333] This system supports decision-making in litigation and provides optimal solutions that take into account the user's emotional state, thereby assisting in effective litigation preparation.

[1334] Example of a prompt:

[1335] "I am considering a lawsuit for breach of contract. The judge's name is X, and my lawyer is Y. The details of the lawsuit are as follows... I am currently experiencing stress."

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

[1337] Step 1:

[1338] Data collection

[1339] Users input litigation information (e.g., type of lawsuit, judge's name, legal documents) and sentiment information through their device. An example of input might be "breach of contract lawsuit, Judge X, Lawyer Y".

[1340] The terminal sends the entered information to the server. At this time, the input information is sent in JSON format or similar.

[1341] The server receives the input information and collects relevant historical litigation data and current legal data from the database. For example, it extracts contract breach litigation data from the past 10 years.

[1342] Input: litigation information, sentiment information

[1343] Output: Past litigation data, legal data

[1344] Step 2:

[1345] Data preprocessing

[1346] The server cleanses the received data, removing inaccurate and duplicate entries. Specifically, this involves actions such as "deleting records with blank judge names" and "merging duplicate litigation data."

[1347] The server identifies missing values ​​and imputes them based on statistical methods. For example, "if past data for Judge Y is missing, it will impute it with the mean."

[1348] The server converts text data into numerical data. For example, it encodes "the judge's name" into a categorical ID.

[1349] Input: Collected litigation data, legal data

[1350] Output: Cleansed and imputed data

[1351] Step 3:

[1352] Feature extraction

[1353] The server extracts features that influence the outcome of a lawsuit. Specifically, it selects features such as "type of lawsuit," "judge's tendencies," and "lawyer's years of experience."

[1354] The server encodes categorical data into numerical data. For example, it converts "Judge X" to "Category ID 1".

[1355] Input: Preprocessed litigation data

[1356] Output: Feature data

[1357] Step 4:

[1358] Model Learning

[1359] The server splits the litigation data into training data and test data. Specifically, it uses "80% as training data and 20% as test data."

[1360] The server uses a selected machine learning model (e.g., Random Forest) to build a model based on the training data.

[1361] The server performs cross-validation to evaluate the model's accuracy. For example, it checks the model's accuracy using "k-fold cross-validation".

[1362] Input: Feature data

[1363] Output: Trained model, model accuracy evaluation results

[1364] Step 5:

[1365] emotion recognition

[1366] The user inputs emotional information into the device. For example, they might input information such as "Stress level: High" and "Sense of security: Low."

[1367] The emotion engine analyzes the input emotional information. Specifically, it uses natural language processing to determine that the user is "highly stressed."

[1368] The server dynamically adjusts prediction results and suggested actions based on emotional information obtained from the emotion engine. For example, if the user enters "high stress level," a relaxation message will be added.

[1369] Input: User sentiment information

[1370] Output: Analyzed sentiment data

[1371] Step 6:

[1372] Prediction and Analysis

[1373] When a user enters new litigation and sentiment information, the server uses a trained model to predict the probability of winning. Specifically, it will display something like, "75% probability of winning this breach of contract lawsuit."

[1374] Based on information from the emotion engine, the server presents the user with the most suitable course of action. Specific action plans might include suggestions such as "review the contract clauses" or "consult with a lawyer in a relaxed environment."

[1375] Input: New litigation information, analyzed sentiment data

[1376] Output: Probability of winning the case, proposed countermeasures

[1377] (Application Example 2)

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

[1379] While systems exist that predict the probability of winning a case and provide appropriate countermeasures based on past precedents and the latest legal information when considering litigation, few systems provide countermeasures that take into account the user's emotional state. Under high-stress conditions, users are less likely to make optimal decisions, resulting in inefficient litigation preparation. Furthermore, dynamically updating litigation information and providing timely advice tailored to the user's emotional state is also difficult. Solving these problems is the objective of this invention.

[1380] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for collecting data from past databases, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to the lawsuit, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, means for recognizing the user's emotional state, means for presenting countermeasures based on the emotional state, and means for providing new lawsuit information and dynamic countermeasures based on the emotional state. This makes it possible to predict the probability of winning with high accuracy based on past precedents and the latest legal information while taking the user's emotional state into consideration, and to provide prompt and appropriate advice.

[1381] definition statement

[1382] "Data collection" is the process of obtaining past case precedents, legal information, and user litigation information from a database.

[1383] "Data cleansing" is the process of removing inaccurate or duplicate data from collected data.

[1384] "Missing value imputation" is the process of filling in missing data based on the mean or existing data.

[1385] "Feature extraction" is a technique for selecting data that may influence the outcome of a lawsuit and converting it into a format that is easy to analyze.

[1386] "Encoding" is the process of converting categorical data into numerical data.

[1387] A "machine learning model" is an algorithm that performs predictions and classifications based on past data.

[1388] "Model learning" is the process of feeding data to a machine learning model to improve its prediction accuracy.

[1389] "Predicting the probability of winning a lawsuit" is the process of predicting the likelihood of winning a lawsuit as a numerical value.

[1390] "Emotion recognition" is a technology that recognizes a user's emotional state from the information they input.

[1391] "Presenting proposed solutions" is the process of providing specific action plans and advice tailored to the user's situation.

[1392] "Dynamic solution provision" refers to a technology that provides solutions in real time based on updated litigation information and emotional states.

[1393] Modes for carrying out the invention

[1394] System Configuration

[1395] The system for carrying out this invention consists of the following main components.

[1396] 1. Server: Performs data collection, cleansing, missing value imputation, feature extraction, encoding, machine learning model training, sentiment recognition, win probability prediction, and proposal of countermeasures.

[1397] 2. User terminal: Provides an interface for inputting litigation information and emotional state, and receiving prediction results and proposed countermeasures.

[1398] 3. Database: Stores past litigation data, legal documents, and the latest information on legal amendments.

[1399] 4. Emotion Engine: Analyzes the user's emotional state and provides data to improve the system's effectiveness.

[1400] Hardware and software to be used

[1401] Hardware: Computer servers, smartphones, network infrastructure

[1402] Software: Python, Pandas, Scikit-learn, emotion_recognition library, database management system

[1403] Program processing

[1404] Data Collection: The server collects necessary data from past litigation databases, user input, and the latest legal databases. This includes the type of litigation, judge information, and relevant legal documents.

[1405] Data cleansing and missing value imputation: The server cleanses the collected data, removing inaccurate and duplicate data. Furthermore, it imputates missing data using mean values ​​and other statistical methods.

[1406] Feature extraction and encoding: The server extracts key features relevant to the litigation and encodes categorical data into numerical data.

[1407] Machine learning model training: The server uses these features to train a machine learning model and evaluates the model's accuracy through cross-validation.

[1408] Emotion Recognition: The system receives emotional information input from the user's device and uses an emotion engine to identify the user's emotional state.

[1409] Predicting the probability of winning: Based on new litigation information and the user's emotional state, the server uses a model to predict the probability of winning.

[1410] Proposal of countermeasures: The server provides the user with the optimal countermeasures based on the prediction results and emotional state.

[1411] Specific example

[1412] For example, if a user is considering a lawsuit for breach of contract, they would input information such as the judge's name and details of past cases. Based on this information, the server would collect relevant data from its historical database and obtain the latest legal information. Next, the server would cleanse the data and impute any missing values. It would use a machine learning model to predict the probability of winning and an emotion engine to recognize the user's emotional state. As a result, the server would predict that there is a "75% chance of winning" and, if the user's emotional state indicates stress, would suggest a course of action such as "consulting with a lawyer in a relaxing environment."

[1413] Example of a prompt

[1414] User input:

[1415] "I am very worried about this lawsuit."

[1416] Emotion recognition prompt:

[1417] "Based on this text, identify the user's emotions, recognize their emotional state (e.g., high stress, feeling at ease), and output the results."

[1418] In this way, the system can provide more appropriate advice based on the user's emotional state and assist in preparing for litigation.

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

[1420] Program processing steps

[1421] Step 1:

[1422] Data collection

[1423] Input: The user enters litigation information (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information into the device.

[1424] Specific operation: The user uses their device to enter litigation-related information into forms and fields. This information is then sent from the device to the server.

[1425] Data processing / calculation: The server uses the received input information as a database query to collect historical litigation data and the latest legal information from the database.

[1426] Output: A set of collected litigation data and legal documents.

[1427] Step 2:

[1428] Data cleansing and missing value imputation

[1429] Input: The dataset collected in Step 1.

[1430] Specific operation: The server analyzes the collected dataset and removes redundant or inaccurate data. Next, it identifies missing data and fills it in using statistical methods (e.g., mean imputation).

[1431] Data processing / calculations: Deleting duplicate data, identifying and imputing missing values.

[1432] Output: Cleansed dataset with no missing values.

[1433] Step 3:

[1434] Feature extraction and encoding

[1435] Input: The dataset cleansed in Step 2.

[1436] Specific operation: The server selects features that may influence the outcome of a lawsuit (e.g., the type of lawsuit and the judge's ruling tendencies). It also encodes categorical data (e.g., the judge's name and the type of lawsuit) into numerical data.

[1437] Data processing / calculations: Feature extraction, numerical conversion of categorical data.

[1438] Output: A dataset with extracted and encoded features.

[1439] Step 4:

[1440] Training machine learning models

[1441] Input: The feature dataset created in Step 3.

[1442] Specific operation: The server splits the dataset into training and test data, and builds a model based on the training data using a selected machine learning model (e.g., Random Forest). Cross-validation is performed to evaluate the accuracy of the model.

[1443] Data processing / computation: Data splitting, model training, and evaluation using cross-validation.

[1444] Output: Trained machine learning model.

[1445] Step 5:

[1446] emotion recognition

[1447] Input: Sentimental information (text data) from the user's terminal.

[1448] Specific operation: The server receives emotional information entered by the user on the device (for example, "I feel very uneasy about this lawsuit"). The server uses the emotion_recognition library to analyze the entered text and recognize the emotional state.

[1449] Data processing / calculation: Analysis of text data, recognition of emotional states.

[1450] Output: Recognized emotional state (e.g., "anxiety").

[1451] Step 6:

[1452] Prediction of the probability of winning the case

[1453] Input: Trained model, Step 3 feature data, new litigation information, Step 5 sentiment state.

[1454] Specific operation: The server uses a pre-trained model to predict the probability of winning the case, taking into account new litigation information and emotional states.

[1455] Data processing / calculation: Inputting feature data into the model, calculating the probability of winning.

[1456] Output: Predicted probability of winning the case.

[1457] Step 7:

[1458] Presentation of countermeasures

[1459] Input: Predicted probability of winning the case, emotional state.

[1460] Specific operation: The server generates optimal countermeasures based on the predicted probability of winning the case and the user's emotional state. For example, if the probability of winning is high and the user is feeling stressed, it will create specific advice such as "consult with a lawyer in a relaxing environment."

[1461] Data processing / calculation: Analysis of prediction results and emotional states, generation of countermeasures.

[1462] Output: Proposed countermeasures as notifications to the user's terminal.

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

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

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

[1466] [Fourth Embodiment]

[1467] Figure 7 shows an example of the configuration of the data processing system 410 according to the fourth embodiment.

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

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

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

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

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

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

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

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

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

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

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

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

[1480] System Configuration

[1481] This invention is a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation, and consists of a server, a user terminal, and a database. The user terminal provides an interface for inputting litigation information, and the server performs data collection, preprocessing, feature extraction, model training, prediction, and result presentation.

[1482] System program processing

[1483] 1. Data Collection

[1484] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) via their device.

[1485] The server receives this input information and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[1486] 2. Data preprocessing

[1487] The server cleanses the collected data, removing inaccurate and duplicate data.

[1488] The server identifies data with missing values ​​and imputes them. For example, it might use statistical methods to impute them with the mean, or predict them based on past trends.

[1489] The server converts the data into a format that is easy for machine learning algorithms to process, and converts text data into numerical data.

[1490] 3. Feature Extraction

[1491] The server selects features from past litigation data that may influence the outcome of a lawsuit. Specific examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[1492] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[1493] 4. Model Learning

[1494] The server splits the dataset into training data and test data, and then builds a model based on the training data using the selected machine learning model.

[1495] The server performs cross-validation and evaluates the accuracy of the model.

[1496] 5. Prediction and Analysis

[1497] When a user enters new litigation information, the server uses a pre-trained model to predict the probability of winning the case based on that information.

[1498] Along with the predicted probability of winning the case, the server presents the user with specific countermeasures. For example, it might suggest concrete action plans such as "review the contract clauses" or "submit additional supporting documents."

[1499] Specific example

[1500] 1. Specific examples of data collection

[1501] For example, if a user is considering a "breach of contract lawsuit," they would enter the judge's name and information about past cases. The server would then retrieve similar lawsuit data from the past 10 years and the latest legal amendments from its database.

[1502] 2. Specific Examples of Data Preprocessing

[1503] The server preprocesses the retrieved data; for example, if there are missing values, it uses the average of similar historical data to fill them in. For non-numeric data, it converts the text to numbers.

[1504] 3. Specific Examples of Feature Extraction

[1505] If the type of lawsuit is "breach of contract," the server extracts features from past court data that influence the outcome of similar lawsuits (e.g., the content of the contract and the presence or absence of evidence).

[1506] 4. Specific Examples of Model Learning

[1507] The server builds a machine learning model using contract breach litigation data and evaluates its accuracy using cross-validation.

[1508] 5. Specific examples of predictions and proposed countermeasures

[1509] When a user provides new litigation information, the server predicts a "75% chance of winning" and suggests specific countermeasures such as "revising the contract clauses and submitting additional evidence."

[1510] This system assists decision-making when considering litigation and provides support to help users proceed with litigation from a more advantageous position.

[1511] The following describes the processing flow.

[1512] Step 1:

[1513] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) via their device.

[1514] Step 2:

[1515] The server receives user input information and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[1516] Step 3:

[1517] The server cleanses the collected data, removing inaccurate and duplicate data.

[1518] Step 4:

[1519] The server identifies data with missing values ​​and imputes them using statistical methods. For example, it might use the mean to impute them.

[1520] Step 5:

[1521] The server converts the data into a format that machine learning algorithms can easily process. Specifically, it converts text data into numerical data.

[1522] Step 6:

[1523] The server selects features from past litigation data that may influence the outcome of a lawsuit. Examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[1524] Step 7:

[1525] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[1526] Step 8:

[1527] The server splits the dataset into training and test data. This makes it easier to evaluate the generalization performance of the model.

[1528] Step 9:

[1529] The server uses the selected machine learning model to build a model based on the training data.

[1530] Step 10:

[1531] The server performs cross-validation and evaluates the accuracy of the model.

[1532] Step 11:

[1533] When a user enters new litigation information, the server uses a pre-trained model to predict the probability of winning the case based on that information.

[1534] Step 12:

[1535] The server presents the user with a predicted probability of winning the case, along with specific countermeasures. For example, it might suggest concrete action plans such as "review the contract clauses" or "submit additional supporting documents."

[1536] (Example 1)

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

[1538] Conventional litigation support systems struggle to provide reliable data analysis and concrete strategies for users to predict the probability of winning a lawsuit. In particular, traditional methods are inefficient at processing inaccurate and duplicate data, imputing missing data, extracting and encoding features, and evaluating the accuracy of machine learning models, resulting in insufficient support for user decision-making.

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

[1540] In this invention, the server includes means for dynamically collecting information from a past database based on litigation information entered by the user; means for cleansing the collected information, removing inaccurate and duplicate data, and supplementing missing data; means for selecting features that affect the outcome of the litigation and encoding categorical data into numerical data; means for building a model based on training data using a machine learning model and evaluating the accuracy of the model by cross-validation; means for predicting the probability of winning from newly entered litigation information based on the trained model; and means for presenting specific countermeasures along with the prediction results. This makes it possible to predict the probability of winning with high accuracy and to present specific and effective litigation countermeasures.

[1541] A "user" is an individual or organization that uses the system to input litigation information and receives predictions of the probability of winning and suggestions for countermeasures.

[1542] "Terminal" refers to a device used by a user to input litigation information, and includes personal computers, smartphones, tablets, etc.

[1543] A "server" is a central processing unit that processes information entered by users and performs data collection, data preprocessing, feature extraction, model training, prediction, and result presentation.

[1544] A "database" is an information storage system used to manage and retrieve past litigation data and the latest legal information.

[1545] "Data cleansing" is the process of removing inaccurate or duplicate data from collected information to improve data consistency and reliability.

[1546] "Missing data imputation" is the process of filling in missing values ​​in a dataset using statistical methods or other data points.

[1547] "Feature extraction" is a process used to identify important data items that may influence the outcome of a lawsuit and to analyze litigation information.

[1548] "Category data encoding" is the process of converting text or categorical data into numerical data that can be processed by machine learning.

[1549] A "machine learning model" is an algorithm that is trained using historical data and then used to make predictions and classifications on new data.

[1550] Cross-validation is a technique for evaluating the generality and accuracy of a model by dividing the training data and performing multiple training and evaluation iterations.

[1551] "Predicting the probability of winning a case" is the process of using a pre-trained model to numerically calculate the likelihood of winning a case based on new litigation information.

[1552] "Presenting countermeasures" is the process of proposing specific actions and strategies that users should take based on the predicted probability of winning the case.

[1553] The following describes in detail the embodiments for which this invention is specifically implemented.

[1554] System Configuration

[1555] This invention is a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation, and consists of a server, a user terminal, and a database. The user terminal provides an interface for inputting litigation information, and the server performs data collection, preprocessing, feature extraction, model training, prediction, and result presentation.

[1556] Hardware and software to be used

[1557] 1. Hardware

[1558] User terminal: A device such as a personal computer, smartphone, or tablet.

[1559] Server: A central processing unit for data processing. A server equipped with a high-performance processor.

[1560] Database: A storage system for managing litigation data. Specifically, MySQL will be used.

[1561] 2. Software

[1562] Data cleansing and imputation: Using the Python Pandas library.

[1563] Feature extraction and encoding: Use CountVectorizer and One-Hot encoding from the Scikit-learn library.

[1564] Model training and accuracy evaluation: Use RandomForestClassifier and cross-validation from the Scikit-learn library.

[1565] Program processing

[1566] 1. Data Collection

[1567] The user enters litigation information through their device. This information includes the type of lawsuit, the judge's information, and relevant legal documents.

[1568] The server receives input information in real time and collects historical litigation data and the latest legal information. Specifically, it uses the Flask framework in Python to receive data and retrieves relevant information from a MySQL database.

[1569] 2. Data preprocessing

[1570] The server cleanses the collected data, removing inaccurate and duplicate entries. This is done using the Python Pandas library.

[1571] The server will impute missing data. Missing values ​​will be filled in using statistical methods, specifically by calculating the mean using the Pandas library.

[1572] The server converts the data format into one that is easily processed by machine learning algorithms. Text data is converted to numerical data using CountVectorizer.

[1573] 3. Feature Extraction

[1574] The server extracts features that influence the outcome of the lawsuit. This process uses the Scikit-learn library to select features such as the type of lawsuit, the judge's ruling tendencies, and the lawyer's experience.

[1575] The server encodes categorical data into numerical data. One-hot encoding is used to convert categorical data into numerical data.

[1576] 4. Model Learning

[1577] The server splits the dataset into training and test data and builds a model using the RandomForestClassifier from the Scikit-learn library.

[1578] The server performs cross-validation to evaluate the model's accuracy. This verifies the model's generality and accuracy.

[1579] 5. Prediction and Analysis

[1580] When a user enters new litigation information, the server uses a pre-trained model to predict the probability of winning the case.

[1581] Based on the prediction results, the server presents the user with specific countermeasures. For example, in the case of a breach of contract lawsuit, it might display a "75% chance of winning" and suggest "revise the contract clauses and submit additional supporting documents."

[1582] Specific example

[1583] 1. Example of data collection

[1584] The user considers filing a "breach of contract lawsuit" and enters the judge's name and details of the lawsuit into their terminal. The server receives this information and collects similar lawsuit data from its MySQL database.

[1585] 2. Examples of data preprocessing

[1586] The server cleanses the collected data using the Pandas library and imputes missing data. For example, it might use the mean of similar historical data to fill in missing values.

[1587] 3. Examples of Feature Extraction

[1588] If the type of lawsuit is "breach of contract," the server extracts features such as the content of the contract and the presence or absence of evidence from past court data.

[1589] 4. Examples of Model Learning

[1590] The server uses contract breach litigation data to build a machine learning model with RandomForestClassifier and performs cross-validation.

[1591] 5. Examples of Predictions and Proposed Countermeasures

[1592] When a user enters new litigation information, the server predicts a "75% chance of winning" and suggests specific countermeasures such as "re-examining the contract clauses" or "submitting additional evidence."

[1593] Example of a prompt

[1594] "We are considering filing a lawsuit for breach of contract. Based on past data from similar lawsuits and the latest legal information, please predict the probability of winning and propose specific countermeasures."

[1595] This system will enable effective support for users' decision-making when considering litigation.

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

[1597] Step 1:

[1598] The user enters litigation information via their device. This input includes the type of litigation, judge information, and relevant legal documents. For example, if the user is considering a "breach of contract lawsuit," they would enter the judge's name and details of the lawsuit. Input: Litigation information (e.g., type of litigation, judge's name, relevant legal documents). Output: Litigation information sent to the endpoint.

[1599] Step 2:

[1600] The server receives litigation information submitted by users in real time. Based on the received information, it executes queries to collect relevant information from historical litigation databases and current legal databases. Specifically, it uses the Flask framework in Python to receive data and retrieve the necessary information from a MySQL database. Input: Litigation information submitted to the endpoint. Output: Historical litigation data and current legal information.

[1601] Step 3:

[1602] The server cleanses the collected data. Specifically, it uses the Pandas library to remove inaccurate and duplicate data. Next, it imputes missing data and converts text data to numerical data. The mean of similar historical data is used to impute missing values. For example, the mean of similar historical litigation data is used to impute missing values. Input: Historical litigation data and recent legal information. Output: Preprocessed dataset.

[1603] Step 4:

[1604] The server extracts features from a preprocessed dataset and encodes categorical data into numerical data. The Scikit-learn library is used for feature extraction, selecting important features (e.g., type of lawsuit, judge's ruling tendencies, lawyer's experience). Categorical data is converted to numerical data using one-hot encoding. Input: Preprocessed dataset. Output: Feature-extracted and encoded dataset.

[1605] Step 5:

[1606] The server trains a machine learning model using a feature-extracted dataset. It splits the dataset into training and test data, and builds and trains the model using the RandomForestClassifier from the Scikit-learn library. The model's accuracy is evaluated using cross-validation. Input: Feature-extracted and encoded dataset. Output: Trained machine learning model and its evaluation results.

[1607] Step 6:

[1608] When a user enters new litigation information, the server predicts the probability of winning based on a trained model. The entered litigation information is fed into the model, and the prediction result is calculated. For example, when new litigation information is entered, "75% probability of winning" is displayed. Input: New litigation information. Output: Predicted probability of winning result.

[1609] Step 7:

[1610] The server presents the user with specific countermeasures based on the prediction results. For example, it might suggest concrete action plans such as "revise the contract clauses and submit additional supporting documents." This allows the user to proceed with the lawsuit from a more advantageous position. Input: Predicted probability of winning. Output: Specific countermeasures.

[1611] Through the processing steps described above, this system provides users with the necessary information analysis and countermeasures when proceeding with litigation, thereby supporting their decision-making.

[1612] (Application Example 1)

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

[1614] Conventional litigation support systems have suffered from insufficient prediction and countermeasures based on past precedents and legal amendments. As a result, users have difficulty making decisions when considering litigation, and risk management is not adequately implemented. Furthermore, there was no means to dynamically analyze the information users entered regarding legal issues and appropriately present specific countermeasures, thus requiring a swift and accurate response.

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

[1616] In this invention, the server includes means for collecting data from a historical database, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to the lawsuit, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, means for receiving input of legal issues from users, visualizing and displaying the results, and means for dynamically generating and presenting specific countermeasures. This enables dynamic analysis when a user inputs a legal issue, allowing for appropriate prediction of the probability of winning and presentation of specific countermeasures.

[1617] A "historical database" is a data storage system that preserves past precedents and legal document information related to litigation.

[1618] "Means of data collection" refers to techniques or methods for extracting necessary data from specific sources and storing it in a database.

[1619] "Data cleansing techniques" are techniques or methods for removing inaccurate or duplicate data in order to improve data quality.

[1620] "Missing value imputation" is the process of appropriately filling in missing data present in a portion of a dataset using statistical methods or inference.

[1621] "Means for extracting features relevant to litigation" refers to techniques or methods for selecting important attributes or elements that influence the outcome of litigation.

[1622] "Encoding means" refers to techniques or methods that convert categorical data into numerical data that can be processed by machine learning algorithms.

[1623] A "machine learning model" is a mathematical algorithm or statistical model that learns patterns and trends based on training data to perform predictions and classifications.

[1624] "Means of building and training" refers to techniques or methods for creating a model using training data and then optimizing its performance.

[1625] "Methods for predicting the probability of winning a case" refer to techniques or methods for probabilistically evaluating the outcome of a lawsuit based on a model.

[1626] "Means of receiving input on legal issues" refers to a technology or method for incorporating legal information provided by users into a system through an interface.

[1627] "Means of visualizing and displaying results" refers to techniques or methods for presenting data or prediction results to users in a visual format such as graphs or charts.

[1628] "Means for dynamically generating and presenting specific countermeasures" refers to a technology or method that generates and proposes actionable countermeasures in real time based on user input information.

[1629] This invention relates to a "corporate compliance monitoring application" that enables companies to anticipate legal issues in advance and take concrete countermeasures. This system consists of a server, user terminals, and a database.

[1630] System Configuration

[1631] The server uses hardware and software to perform the following functions:

[1632] For data collection and cleansing, we use database management systems (MySQL, PostgreSQL) and data analysis libraries (Pandas).

[1633] Feature extraction and encoding will be performed using the machine learning library (Scikit-learn).

[1634] Random Forest is used to build and train machine learning models.

[1635] The user terminal provides an interface for legal personnel to input information on legal issues and visually displays predicted results and proposed solutions from the server. A web browser or mobile application is used for the graphical user interface (GUI).

[1636] The database stores past case precedents and information on legal amendments, and is used by the server to dynamically search and extract the necessary data.

[1637] System processing

[1638] 1. Data collection:

[1639] The server receives information about legal issues sent from user terminals and collects relevant past case data and the latest legal amendment information from its database.

[1640] 2. Data preprocessing:

[1641] The server cleanses the collected data, removing inaccurate and duplicate data. Furthermore, it imputes missing values ​​and encodes categorical data into numerical data.

[1642] 3. Feature extraction and model training:

[1643] The server extracts features relevant to the lawsuit and builds a machine learning model based on historical data. The model's accuracy is evaluated using cross-validation.

[1644] 4. Predictions and proposed countermeasures:

[1645] When a new legal issue is entered by a user, the server predicts the probability of winning the case based on its model and dynamically generates and presents specific countermeasures. The prediction results and countermeasures are displayed visually on the user's terminal.

[1646] Program Processing Description

[1647] The server first receives information about legal issues and collects relevant data from historical databases. During the data collection process, a database management system (MySQL, PostgreSQL) is used to search for and extract the necessary data. Subsequently, the Pandas data analysis library is used to cleanse the data and impute missing values.

[1648] Next, the server extracts features related to the lawsuit from the collected data and encodes them into numerical data. Scikit-learn is used for this process. The Random Forest algorithm is employed for model construction and training, and the model's accuracy is evaluated by performing cross-validation.

[1649] When a user enters a new legal issue, the server predicts the probability of winning based on a trained model and displays this visually on the user's terminal. In addition, it dynamically generates proposed solutions and presents the user with a concrete action plan. This allows the user to take quick and appropriate action.

[1650] Specific example

[1651] For example, if a user is considering a "breach of contract lawsuit," they enter the judge's name and information about past cases. The server then retrieves data on similar lawsuits from the past 10 years and the latest legal amendments from its database and processes it. As a result, it displays a "75% chance of winning" and suggests countermeasures such as "reviewing the contract clauses and submitting additional evidence."

[1652] An example of a prompt message for a generative AI model is: "Build a model to predict the probability of winning a current legal issue based on past case data collected by a compliance monitoring application. Use features such as the type of legal issue, judge information, and legal documents to predict the probability of winning and create a prompt message that suggests specific countermeasures."

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

[1654] Step 1:

[1655] Data collection

[1656] The server receives information about the legal issue entered by the user (e.g., type of lawsuit, judge information, relevant documents). Based on this input, the server collects relevant case law data and the latest legal amendment information from its historical database.

[1657] Input: Information on legal issues

[1658] Output: Collected historical case law data and information on legal amendments.

[1659] Specifically, the server uses a database management system (MySQL, PostgreSQL) to query and retrieve the relevant data. For example, it might collect data on contract breaches over the past 10 years or information on the latest legal changes.

[1660] Step 2:

[1661] Data preprocessing

[1662] The server cleanses the collected data, removing inaccurate and duplicate data. If the collected data contains missing values, statistical methods are used to impute them.

[1663] Input: Collected historical case law data and information on legal amendments.

[1664] Output: Cleansed and imputed data

[1665] Specifically, the data is preprocessed using the Pandas data analysis library. Inaccurate and duplicate data are removed, and missing values ​​are imputed by predicting them from the mean or historical trends.

[1666] Step 3:

[1667] Feature extraction and encoding

[1668] The server extracts features from the cleansed data that could potentially influence the outcome of the lawsuit and encodes categorical data into numerical data.

[1669] Input: Cleansed data

[1670] Output: Data with extracted and encoded features

[1671] Specifically, the Scikit-learn library is used to quantify features such as the type of lawsuit, the judge's tendencies, and the content of legal documents. Categorical data is converted to numerical values ​​using LabelEncoder.

[1672] Step 4:

[1673] Model Learning

[1674] The server builds a machine learning model based on the data from which features have been extracted and encoded, and then trains it using the training data. After training, cross-validation is performed to evaluate the accuracy of the model.

[1675] Input: Data from which features have been extracted and encoded.

[1676] Output: Trained machine learning model

[1677] The server builds a model using the RandomForest algorithm from the Scikit-learn library, splits the data into training and test sets, and trains the model. Cross-validation is used to evaluate the model's accuracy and select the optimal model.

[1678] Step 5:

[1679] Predictions and proposed countermeasures

[1680] When a user inputs information about a new legal issue, the server predicts the probability of winning based on a trained model. It visualizes the prediction and displays it on the user's terminal, dynamically generating and proposing specific countermeasures.

[1681] Input: Information on new legal issues

[1682] Output: Predicted probability of winning the case and specific countermeasures.

[1683] Specifically, the server inputs data on new legal issues into a pre-trained model and obtains a predicted probability of winning. It then uses visualization tools to display the results in graphs and charts and presents specific countermeasures (e.g., reviewing contract clauses and submitting additional evidence).

[1684] Examples of prompts for a generative AI model:

[1685] "Based on past case data collected by a compliance monitoring application, we will build a model to predict the probability of winning current legal cases. Using features such as the type of legal issue, judge information, and legal documents, we will predict the probability of winning and create prompt messages suggesting specific countermeasures."

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

[1687] System Configuration

[1688] This invention relates to a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation, and consists of a server, a user terminal, a database, and an emotion engine. The user terminal provides an interface for inputting litigation information and the user's emotions, the server collects data, preprocesses it, extracts features, trains the model, makes predictions, and presents results, and the emotion engine recognizes the user's emotions and improves the system's performance.

[1689] System program processing

[1690] 1. Data Collection

[1691] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information via their device.

[1692] The server receives this input information and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[1693] 2. Data preprocessing

[1694] The server cleanses the collected data, removing inaccurate and duplicate data.

[1695] The server identifies data with missing values ​​and imputes them. For example, it might use statistical methods to impute them with the mean.

[1696] The server converts the data into a format that is easy for machine learning algorithms to process, and converts text data into numerical data.

[1697] 3. Feature Extraction

[1698] The server selects features from past litigation data that may influence the outcome of a lawsuit. Specific examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[1699] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[1700] 4. Model Learning

[1701] The server splits the dataset into training data and test data, and then builds a model based on the training data using the selected machine learning model.

[1702] The server performs cross-validation and evaluates the accuracy of the model.

[1703] 5. Emotion recognition

[1704] The emotion engine receives emotional information entered by the user and recognizes those emotions.

[1705] The server dynamically adjusts prediction results and suggested countermeasures based on user emotion information obtained from the emotion engine.

[1706] 6. Prediction and Analysis

[1707] When a user inputs new litigation information and sentiment information, the server uses that information to predict the probability of winning the case using a pre-trained model.

[1708] Along with the predicted probability of winning, the server uses information from the emotion engine to suggest the most suitable course of action to the user. For example, it might suggest specific action plans such as "review the contract clauses" or "submit additional supporting documents."

[1709] Specific example

[1710] 1. Specific examples of data collection

[1711] For example, if a user is considering a "breach of contract lawsuit," they would enter the judge's name and information about past cases. The server would then retrieve similar lawsuit data from the past 10 years and the latest legal amendments from its database.

[1712] 2. Specific Examples of Data Preprocessing

[1713] The server preprocesses the retrieved data; for example, if there are missing values, it uses the average of similar historical data to fill them in. For non-numeric data, it converts the text to numbers.

[1714] 3. Specific Examples of Feature Extraction

[1715] If the type of lawsuit is "breach of contract," the server extracts features from past court data that influence the outcome of similar lawsuits (e.g., the content of the contract and the presence or absence of evidence).

[1716] 4. Specific Examples of Model Learning

[1717] The server builds a machine learning model using contract breach litigation data and evaluates its accuracy using cross-validation.

[1718] 5. Specific examples of emotion recognition

[1719] When a user inputs emotional information into the device, the emotion engine analyzes that information and recognizes emotional states such as "high stress" or "feeling at ease."

[1720] 6. Specific examples of predictions and proposed countermeasures

[1721] When a user provides new litigation and sentiment information, the server uses data from the sentiment engine to predict a "75% chance of winning" and suggests, for example, if the user is feeling stressed, to "consult with a lawyer in a relaxing environment" or "review contract clauses and submit additional evidence."

[1722] This system not only assists in decision-making when considering litigation, but also supports more appropriate and effective litigation preparation by providing countermeasures that take into account the user's emotional state.

[1723] The following describes the processing flow.

[1724] Step 1:

[1725] The user enters current litigation information (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information via their device.

[1726] Step 2:

[1727] The server receives input information from users and collects relevant data from a database of past litigation cases. It also collects information on legal amendments and recent case precedents from the latest legal database.

[1728] Step 3:

[1729] The server cleanses the collected data, removing inaccurate and duplicate data.

[1730] Step 4:

[1731] The server identifies data with missing values ​​and uses statistical methods to impute those missing values ​​with the mean.

[1732] Step 5:

[1733] The server converts the data into a format that machine learning algorithms can easily process. Specifically, it converts text data into numerical data.

[1734] Step 6:

[1735] The server selects features from past litigation data that may influence the outcome of a lawsuit. Examples include the type of lawsuit, the judge's tendencies, and the lawyer's experience.

[1736] Step 7:

[1737] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data.

[1738] Step 8:

[1739] The server splits the dataset into training and test data. This makes it easier to evaluate the generalization performance of the model.

[1740] Step 9:

[1741] The server uses the selected machine learning model to build a model based on the training data.

[1742] Step 10:

[1743] The server performs cross-validation and evaluates the accuracy of the model.

[1744] Step 11:

[1745] The server uses an emotion engine to recognize emotions based on user input. For example, if the user answers "anxious," the emotion engine processes that emotional state as data.

[1746] Step 12:

[1747] The emotion engine sends the recognized emotion information to the server, which then adjusts the prediction results and proposed countermeasures based on this information.

[1748] Step 13:

[1749] When a user inputs new litigation information and sentiment information, the server uses that information to predict the probability of winning the case using a pre-trained model.

[1750] Step 14:

[1751] The server presents the user with the most suitable course of action based on information from the emotion engine, along with the predicted probability of winning the case. For example, if the probability of winning is 75% and the user is experiencing high stress, the server will suggest action plans such as "reviewing the contract terms" and "submitting additional evidence," as well as "consulting with an expert in a relaxed environment."

[1752] Specific example

[1753] 1. Specific examples of data collection

[1754] A user considers filing a lawsuit for breach of contract and enters information such as the judge's name and details of past cases. The server then retrieves data on similar lawsuits from the past 10 years and the latest legal amendments from its database.

[1755] 2. Specific Examples of Data Preprocessing

[1756] The server preprocesses the retrieved data; for example, if there are missing values, it uses the average of similar historical data to fill them in. For non-numeric data, it converts the text to numbers.

[1757] 3. Specific Examples of Feature Extraction

[1758] If the type of lawsuit is "breach of contract," the server extracts features from past court data that influence the outcome of similar lawsuits (e.g., the content of the contract and the presence or absence of evidence).

[1759] 4. Specific Examples of Model Learning

[1760] The server builds a machine learning model using contract breach litigation data and evaluates its accuracy using cross-validation.

[1761] 5. Specific examples of emotion recognition

[1762] When a user inputs emotional information into the device, they select an emotion such as "anxiety," "anticipation," or "stress." The emotion engine analyzes this information and recognizes the user's emotional state.

[1763] 6. Specific examples of predictions and proposed countermeasures

[1764] Based on the newly provided litigation and emotional information from the user, the server predicts a "75% chance of winning" using data from the emotional engine. For example, if the user is feeling anxious, it suggests "revising the contract clauses and submitting additional evidence" as well as "consulting a psychological counselor."

[1765] This system not only assists in decision-making when considering litigation, but also supports more appropriate and effective litigation preparation by providing countermeasures that take into account the user's emotional state.

[1766] (Example 2)

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

[1768] Conventional litigation support systems have a problem in that they predict the probability of winning a lawsuit and suggest countermeasures without considering the user's emotional state, making it difficult for users to make informed decisions. Furthermore, the accuracy of predictions is also hampered by incomplete or redundant input data.

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

[1770] In this invention, the server includes means for collecting data from a historical database, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to the lawsuit, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, means for presenting the prediction results and proposed countermeasures, means for inputting and analyzing emotional information from the user, and means for dynamically adjusting the prediction results and proposed countermeasures based on the analyzed emotional information. This makes it possible to predict the probability of winning with high accuracy and present appropriate countermeasures that take into account the user's emotional state.

[1771] "Data collection" is the process of gathering necessary information from past databases.

[1772] "Data cleansing" is the process of removing inaccurate or duplicate data from collected data.

[1773] "Missing value imputation" is the process of filling in missing values ​​in a dataset with appropriate values.

[1774] "Feature extraction" is the process of selecting features from data that may influence the outcome of a lawsuit.

[1775] "Encoding" is the process of converting categorical data into numerical data.

[1776] A "machine learning model" is a collection of algorithms trained to make predictions and classifications based on data.

[1777] "Model training" is the process of training a machine learning model using collected data.

[1778] "Predicting the probability of winning a lawsuit" is the process of calculating the probability of winning a lawsuit using a trained machine learning model.

[1779] "Prediction result" refers to the output value calculated by the machine learning model.

[1780] "Presenting proposed solutions" means providing users with guidance on what to do based on the prediction results.

[1781] "Emotional information" refers to data that indicates the user's mental state.

[1782] "Emotional analysis" is the process of evaluating a user's mental state based on the emotional information they have entered.

[1783] "Dynamic adjustment" refers to changing the system's behavior and output in real time based on analyzed emotional information.

[1784] This invention relates to a system that analyzes predictions of winning a lawsuit and trends in countermeasures when a user is considering litigation. The system consists of a server, a user terminal, a database, and an emotion engine. The user terminal provides an interface for inputting litigation information and the user's emotions, while the server performs data collection, preprocessing, feature extraction, model training, prediction, and results presentation. The emotion engine recognizes the user's emotions and improves the system's performance.

[1785] Hardware and software to be used

[1786] Server: A server with high-performance computing capabilities is required. For example, a server equipped with an Intel processor would be used.

[1787] User terminal: This refers to a device used by the user to input data, such as a personal computer or smartphone. For example, devices running Windows or iOS are suitable.

[1788] Database: A database is needed to store past litigation information and legal data. A relational database such as MySQL or PostgreSQL will be used.

[1789] Emotion Engine: This software uses natural language processing (NLP) or emotion analysis engines to analyze user emotion information. Examples include open-source emotion analysis libraries such as NLTK and TextBlob.

[1790] Machine learning libraries: Machine learning libraries such as TensorFlow and Scikit-learn are used to build and train models.

[1791] Explanation of the process

[1792] Data collection

[1793] Users input information about the lawsuit (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information through their device. For example, if a user is considering a "breach of contract lawsuit," they would input the judge's name and information about past cases.

[1794] The server receives this input information and collects relevant data from its historical litigation database. It also collects information on legal amendments and recent case precedents from its up-to-date legal database. For example, it retrieves data on similar litigation from the past 10 years and information on recent legal amendments.

[1795] Data preprocessing

[1796] The server cleanses the collected data, removing inaccurate and duplicate entries. For example, it might delete duplicate records for the same case.

[1797] The server identifies data with missing values ​​and imputes them using statistical methods. For example, it might fill in missing values ​​with the mean of past data.

[1798] The server converts the data into a format that machine learning algorithms can easily process. For example, it encodes text data into categorical data and converts it into numerical data.

[1799] Feature extraction

[1800] The server selects features from past litigation data that may influence the outcome of a lawsuit. For example, in a "breach of contract" lawsuit, the content of the contract and the presence or absence of evidence are important features.

[1801] The server encodes categorical data (e.g., judge's name, type of lawsuit) into numerical data. For example, it assigns a unique numerical ID to a judge's name.

[1802] Model Learning

[1803] The server splits the dataset into training data and test data, and then builds a model based on the training data using the selected machine learning model. For example, it might split the dataset into 80% training data and 20% test data.

[1804] The server performs cross-validation to evaluate the model's accuracy. For example, it verifies the model's accuracy by performing k-fold cross-validation.

[1805] emotion recognition

[1806] The user inputs emotional information into the device. For example, they might input emotions such as "high stress" or "feeling relieved."

[1807] The emotion engine analyzes the input emotion information to identify the user's emotional state. For example, it uses natural language processing to analyze emotions from user input.

[1808] The server dynamically adjusts prediction results and suggested actions based on emotional information obtained from the emotion engine. For example, if the user is feeling stressed, a relaxation message will be added to the suggested actions.

[1809] Prediction and Analysis

[1810] When a user enters new litigation and sentiment information, the server uses a trained model to predict the probability of winning. For example, it might display "75% probability of winning this breach of contract lawsuit."

[1811] Based on information from the emotion engine, the server presents the user with the most suitable course of action. For example, it provides specific action plans such as "review the contract clauses" or "submit additional supporting documents."

[1812] Specific example

[1813] If a user is considering a "breach of contract lawsuit," they enter information such as "Judge's name: X, Lawyer's name: Y, Summary of the lawsuit" into their device. The server receives this information and collects similar lawsuit data from its database of past lawsuits. Additionally, if the user enters "I am feeling stressed," the emotion engine analyzes this, and the server provides additional suggestions for countermeasures corresponding to the stress level.

[1814] This system supports decision-making in litigation and provides optimal solutions that take into account the user's emotional state, thereby assisting in effective litigation preparation.

[1815] Example of a prompt:

[1816] "I am considering a lawsuit for breach of contract. The judge's name is X, and my lawyer is Y. The details of the lawsuit are as follows... I am currently experiencing stress."

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

[1818] Step 1:

[1819] Data collection

[1820] Users input litigation information (e.g., type of lawsuit, judge's name, legal documents) and sentiment information through their device. An example of input might be "breach of contract lawsuit, Judge X, Lawyer Y".

[1821] The terminal sends the entered information to the server. At this time, the input information is sent in JSON format or similar.

[1822] The server receives the input information and collects relevant historical litigation data and current legal data from the database. For example, it extracts contract breach litigation data from the past 10 years.

[1823] Input: litigation information, sentiment information

[1824] Output: Past litigation data, legal data

[1825] Step 2:

[1826] Data preprocessing

[1827] The server cleanses the received data, removing inaccurate and duplicate entries. Specifically, this involves actions such as "deleting records with blank judge names" and "merging duplicate litigation data."

[1828] The server identifies missing values ​​and imputes them based on statistical methods. For example, "if past data for Judge Y is missing, it will impute it with the mean."

[1829] The server converts text data into numerical data. For example, it encodes "the judge's name" into a categorical ID.

[1830] Input: Collected litigation data, legal data

[1831] Output: Cleansed and imputed data

[1832] Step 3:

[1833] Feature extraction

[1834] The server extracts features that influence the outcome of a lawsuit. Specifically, it selects features such as "type of lawsuit," "judge's tendencies," and "lawyer's years of experience."

[1835] The server encodes categorical data into numerical data. For example, it converts "Judge X" to "Category ID 1".

[1836] Input: Pre-processed litigation data

[1837] Output: Feature data

[1838] Step 4:

[1839] Model Learning

[1840] The server splits the litigation data into training data and test data. Specifically, it uses "80% as training data and 20% as test data."

[1841] The server uses a selected machine learning model (e.g., Random Forest) to build a model based on the training data.

[1842] The server performs cross-validation to evaluate the model's accuracy. For example, it checks the model's accuracy using "k-fold cross-validation".

[1843] Input: Feature data

[1844] Output: Trained model, model accuracy evaluation results

[1845] Step 5:

[1846] emotion recognition

[1847] The user inputs emotional information into the device. For example, they might input information such as "Stress level: High" and "Sense of security: Low."

[1848] The emotion engine analyzes the input emotional information. Specifically, it uses natural language processing to determine that the user is "highly stressed."

[1849] The server dynamically adjusts prediction results and suggested actions based on emotional information obtained from the emotion engine. For example, if the user enters "high stress level," a relaxation message will be added.

[1850] Input: User sentiment information

[1851] Output: Analyzed sentiment data

[1852] Step 6:

[1853] Prediction and Analysis

[1854] When a user enters new litigation and sentiment information, the server uses a trained model to predict the probability of winning. Specifically, it will display something like, "75% probability of winning this breach of contract lawsuit."

[1855] Based on information from the emotion engine, the server presents the user with the most suitable course of action. Specific action plans might include suggestions such as "review the contract clauses" or "consult with a lawyer in a relaxed environment."

[1856] Input: New litigation information, analyzed sentiment data

[1857] Output: Probability of winning the case, proposed countermeasures

[1858] (Application Example 2)

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

[1860] While systems exist that predict the probability of winning a case and provide appropriate countermeasures based on past precedents and the latest legal information when considering litigation, few systems provide countermeasures that take into account the user's emotional state. Under high-stress conditions, users are less likely to make optimal decisions, resulting in inefficient litigation preparation. Furthermore, dynamically updating litigation information and providing timely advice tailored to the user's emotional state is also difficult. Solving these problems is the objective of this invention.

[1861] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for collecting data from past databases, means for cleansing and imputing missing values ​​in the collected data, means for extracting and encoding features related to the lawsuit, means for building and training a machine learning model, means for predicting the probability of winning based on the trained model, means for recognizing the user's emotional state, means for presenting countermeasures based on the emotional state, and means for providing new lawsuit information and dynamic countermeasures based on the emotional state. This makes it possible to predict the probability of winning with high accuracy based on past precedents and the latest legal information while taking the user's emotional state into consideration, and to provide prompt and appropriate advice.

[1862] definition statement

[1863] "Data collection" is the process of obtaining past case precedents, legal information, and user litigation information from a database.

[1864] "Data cleansing" is the process of removing inaccurate or duplicate data from collected data.

[1865] "Missing value imputation" is the process of filling in missing data based on the mean or existing data.

[1866] "Feature extraction" is a technique for selecting data that may influence the outcome of a lawsuit and converting it into a format that is easy to analyze.

[1867] "Encoding" is the process of converting categorical data into numerical data.

[1868] A "machine learning model" is an algorithm that performs predictions and classifications based on past data.

[1869] "Model learning" is the process of feeding data to a machine learning model to improve its prediction accuracy.

[1870] "Predicting the probability of winning a lawsuit" is the process of predicting the likelihood of winning a lawsuit as a numerical value.

[1871] "Emotion recognition" is a technology that recognizes a user's emotional state from the information they input.

[1872] "Presenting proposed solutions" is the process of providing specific action plans and advice tailored to the user's situation.

[1873] "Dynamic solution provision" refers to a technology that provides solutions in real time based on updated litigation information and emotional states.

[1874] Modes for carrying out the invention

[1875] System Configuration

[1876] The system for carrying out this invention consists of the following main components.

[1877] 1. Server: Performs data collection, cleansing, missing value imputation, feature extraction, encoding, machine learning model training, sentiment recognition, win probability prediction, and proposal of countermeasures.

[1878] 2. User terminal: Provides an interface for inputting litigation information and emotional state, and receiving prediction results and proposed countermeasures.

[1879] 3. Database: Stores past litigation data, legal documents, and the latest information on legal amendments.

[1880] 4. Emotion Engine: Analyzes the user's emotional state and provides data to improve the system's effectiveness.

[1881] Hardware and software to be used

[1882] Hardware: Computer servers, smartphones, network infrastructure

[1883] Software: Python, Pandas, Scikit-learn, emotion_recognition library, database management system

[1884] Program processing

[1885] Data Collection: The server collects necessary data from past litigation databases, user input, and the latest legal databases. This includes the type of litigation, judge information, and relevant legal documents.

[1886] Data cleansing and missing value imputation: The server cleanses the collected data, removing inaccurate and duplicate data. Furthermore, it imputates missing data using mean values ​​and other statistical methods.

[1887] Feature extraction and encoding: The server extracts key features relevant to the litigation and encodes categorical data into numerical data.

[1888] Machine learning model training: The server uses these features to train a machine learning model and evaluates the model's accuracy through cross-validation.

[1889] Emotion Recognition: The system receives emotional information input from the user's device and uses an emotion engine to identify the user's emotional state.

[1890] Predicting the probability of winning: Based on new litigation information and the user's emotional state, the server uses a model to predict the probability of winning.

[1891] Proposal of countermeasures: The server provides the user with the optimal countermeasures based on the prediction results and emotional state.

[1892] Specific example

[1893] For example, if a user is considering a lawsuit for breach of contract, they would input information such as the judge's name and details of past cases. Based on this information, the server would collect relevant data from its historical database and obtain the latest legal information. Next, the server would cleanse the data and impute any missing values. It would use a machine learning model to predict the probability of winning and an emotion engine to recognize the user's emotional state. As a result, the server would predict that there is a "75% chance of winning" and, if the user's emotional state indicates stress, would suggest a course of action such as "consulting with a lawyer in a relaxing environment."

[1894] Example of a prompt

[1895] User input:

[1896] "I am very worried about this lawsuit."

[1897] Emotion recognition prompt:

[1898] "Based on this text, identify the user's emotions, recognize their emotional state (e.g., high stress, feeling at ease), and output the results."

[1899] In this way, the system can provide more appropriate advice based on the user's emotional state and assist in preparing for litigation.

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

[1901] Program processing steps

[1902] Step 1:

[1903] Data collection

[1904] Input: The user enters litigation information (type of lawsuit, judge information, relevant legal documents, etc.) and sentiment information into the device.

[1905] Specific operation: The user uses their device to enter litigation-related information into forms and fields. This information is then sent from the device to the server.

[1906] Data processing / calculation: The server uses the received input information as a database query to collect historical litigation data and the latest legal information from the database.

[1907] Output: A set of collected litigation data and legal documents.

[1908] Step 2:

[1909] Data cleansing and missing value imputation

[1910] Input: The dataset collected in Step 1.

[1911] Specific operation: The server analyzes the collected dataset and removes redundant or inaccurate data. Next, it identifies missing data and fills it in using statistical methods (e.g., mean imputation).

[1912] Data processing / calculations: Deleting duplicate data, identifying and imputing missing values.

[1913] Output: Cleansed dataset with no missing values.

[1914] Step 3:

[1915] Feature extraction and encoding

[1916] Input: The dataset cleansed in Step 2.

[1917] Specific operation: The server selects features that may influence the outcome of a lawsuit (e.g., the type of lawsuit and the judge's ruling tendencies). It also encodes categorical data (e.g., the judge's name and the type of lawsuit) into numerical data.

[1918] Data processing / calculations: Feature extraction, numerical conversion of categorical data.

[1919] Output: A dataset with extracted and encoded features.

[1920] Step 4:

[1921] Training machine learning models

[1922] Input: The feature dataset created in Step 3.

[1923] Specific operation: The server splits the dataset into training and test data, and builds a model based on the training data using a selected machine learning model (e.g., random forest). Cross-validation is performed to evaluate the accuracy of the model.

[1924] Data processing / computation: Data splitting, model training, and evaluation using cross-validation.

[1925] Output: Trained machine learning model.

[1926] Step 5:

[1927] emotion recognition

[1928] Input: Sentimental information (text data) from the user's terminal.

[1929] Specific operation: The server receives emotional information entered by the user on the device (for example, "I feel very uneasy about this lawsuit"). The server uses the emotion_recognition library to analyze the entered text and recognize the emotional state.

[1930] Data processing / calculation: Analysis of text data, recognition of emotional states.

[1931] Output: Recognized emotional state (e.g., "anxiety").

[1932] Step 6:

[1933] Prediction of the probability of winning the case

[1934] Input: Trained model, Step 3 feature data, new litigation information, Step 5 sentiment state.

[1935] Specific operation: The server uses a pre-trained model to predict the probability of winning the case, taking into account new litigation information and emotional states.

[1936] Data processing / calculation: Inputting feature data into the model, calculating the probability of winning.

[1937] Output: Predicted probability of winning the case.

[1938] Step 7:

[1939] Presentation of countermeasures

[1940] Input: Predicted probability of winning the case, emotional state.

[1941] Specific operation: The server generates optimal countermeasures based on the predicted probability of winning the case and the user's emotional state. For example, if the probability of winning is high and the user is feeling stressed, it will create specific advice such as "consult with a lawyer in a relaxing environment."

[1942] Data processing / calculation: Analysis of prediction results and emotional states, generation of countermeasures.

[1943] Output: Proposed countermeasures as notifications to the user's terminal.

[1944] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the controlled object 443 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.

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

[1946] 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 robot 414.

[1947] Furthermore, the emotion identification model 59, acting as an emotion engine, may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to a specific mapping, which is an emotion map (see Figure 9). Similarly, the emotion identification model 59 may also determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1948] Figure 9 shows an emotion map 400 in which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. The closer to the center of the concentric circles, the more primitive the emotions are located. Further out of the concentric circles, emotions representing states and actions arising from mental states are located. Emotion is a concept that includes feelings and mental states. On the left side of the concentric circles, emotions that are generally generated from reactions occurring in the brain are located. On the right side of the concentric circles, emotions that are generally induced by situational judgment are located. Above and below the concentric circles, emotions that are generally generated from reactions occurring in the brain and induced by situational judgment are located. In addition, the emotion of "pleasure" is located on the upper side of the concentric circles, and the emotion of "displeasure" is located on the lower side. Thus, in the emotion map 400, multiple emotions are mapped based on the structure in which emotions arise, and emotions that are likely to occur simultaneously are mapped close together.

[1949] These emotions are distributed at the 3 o'clock position on the Emotion Map 400, and usually fluctuate between feelings of security and anxiety. In the right half of the Emotion Map 400, situational awareness takes precedence over internal feelings, resulting in a calm impression.

[1950] The inside of the Emotion Map 400 represents inner thoughts, while the outside represents actions. Therefore, the further you go from the outside of the Emotion Map 400, the more visible (expressed in actions) your emotions become.

[1951] Here, human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. Similarly, in robots, cars, motorcycles, etc., emotions can be created based on various balances, such as posture and battery level. When these balances deviate from the ideal, it results in discomfort, and when they approach the ideal, it results in pleasure. The emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on a system for analyzing brain physiological signals of speech emotion recognition and emotion, Tokushima University, doctoral dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map contains emotions belonging to a region called "response," where sensation is dominant. The right half of the emotion map contains emotions belonging to a region called "situation," where situational awareness is dominant.

[1952] The emotion map defines two emotions that promote learning. One is the emotion around the middle of the negative "repentance" and "reflection" on the situation side. In other words, it is when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded ag...

Claims

1. Methods for collecting data from past databases, A means for cleansing and imputing missing values ​​in the collected data, Means for extracting and encoding features related to litigation, Means for building and training machine learning models, A means of predicting the probability of winning a case based on a trained model, A system that includes means for presenting prediction results and proposed countermeasures.

2. The system according to claim 1, which dynamically searches and extracts relevant past data based on user input information.

3. The system according to claim 1, which evaluates the accuracy of a trained model by cross-validation.

Images