System

Abstract

A system is provided.SOLUTION: A system comprising: means for automatically generating and explaining rules in an organization using a generative model; means for providing an interface for a user to input new rules; means for matching new rules with existing rules and detecting conflicts; and means for displaying detected conflict information to a user.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] The rules and precautions established within an organization are often complex, making it difficult to understand them concisely and disseminate them widely. Furthermore, when new rules are introduced, they may conflict with existing rules, and it is not easy to detect and resolve these conflicts. There is a need for a method to solve these issues and share and manage rules efficiently and effectively. [Means for solving the problem]

[0005] The present invention provides a system that includes a means for automatically generating and explaining rules in an organization using a generative model, a means for providing an interface for a user to input new rules, a means for matching the new rules with existing rules to detect conflicts, and a means for displaying detected conflict information to the user. This system simplifies the dissemination of complex rules and makes it easy to detect conflicts with existing rules when introducing new rules.

[0006] A "generative model" refers to a machine learning algorithm that generates new information based on existing data.

[0007] "Rules within an organization" refers to the regulations and precautions that employees and members must follow in a particular organization.

[0008] "Automatically generated" refers to the process by which software or algorithms create new information without human intervention.

[0009] "Explanation" refers to explaining the background and impact of new rules or information to make it easier to understand.

[0010] "User" refers to the end user who utilizes the system to input new rules and review generated information.

[0011] "Interface" refers to the screen and input devices that allow a user to operate the system and input and output data.

[0012] "Matching" refers to the process of comparing new rules entered with existing rules to check for matches and inconsistencies.

[0013] "Detect conflicts" refers to checking for contradictions or conflicts between new rules and existing rules and finding inconsistencies.

[0014] "Conflict information" refers to data that details the conflicts or inconsistencies that arise between new rules and existing rules.

[0015] "Display" refers to the process of making the information or results generated by the system visible to the user. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0024] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0037] The present invention relates to a system that automatically generates and explains rules within an organization using a generative model. This system has an interface for users to input new rules, compares the new rules with existing rules, detects conflicts, and displays them to the user. Specific embodiments for implementing the present invention are described below.

[0038] System configuration

[0039] Server side

[0040] The server has the following main functions:

[0041] 1. Load Generative Model: The server loads and initializes a pre-trained generative model, which is used to generate explanations for new rules.

[0042] 2. Receiving a request: The server receives an HTTP POST request sent from the terminal, which includes the new rules entered by the user.

[0043] 3. Explanation generation using the generative model: The server inputs a new rule into the generative model and generates a detailed explanation for that rule.

[0044] 4. Conflict Detection: The server detects possible inconsistencies or conflicts between new rules and existing rules.

[0045] 5. Response generation: The server compiles the generated explanation and detected conflict information and sends it to the terminal as a JSON-formatted response.

[0046] Terminal side

[0047] The terminal has the following main features:

[0048] 1. Providing a user interface: The terminal provides an interface for the user to enter new rules, including a text box and a submit button.

[0049] 2. Obtaining user input: The terminal obtains the rules entered by the user and generates a request to send to the server.

[0050] 3. Displaying the response: The terminal analyzes the response received from the server and displays the generated explanation and conflict information to the user.

[0051] Specific examples

[0052] User operations

[0053] 1. The user enters "Prohibit use of smartphones during meetings" into the device's user interface and clicks the send button.

[0054] 2. The device converts the rules into JSON format and sends it to the server as an HTTP POST request.

[0055] Server Processing

[0056] 1. The server receives the request and extracts a new rule: "Do not use smartphones during meetings."

[0057] 2. The server inputs this rule into the generative model and generates an explanation: "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[0058] 3. The server compares the new rule with existing rules and detects any conflicts with the existing rule, "Smartphone use is permitted during meetings if there is an important message to be communicated."

[0059] 4. The server generates a JSON response containing the generated explanation and discrepancies and sends it to the device.

[0060] Terminal handling

[0061] 1. The terminal receives the response from the server and analyzes it.

[0062] 2. The device displays the analysis results to the user and notifies them, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule: Smartphone use is permitted during meetings if there is an important message to be communicated."

[0063] This system allows users to effectively receive explanations of new rules and proactively identify conflicts with existing rules, resulting in fast and efficient rule dissemination throughout the organization.

[0064] The processing flow will be explained below.

[0065] Step 1:

[0066] The user enters a new rule into the device's user interface, for example, "Do not use smartphones during meetings."

[0067] Step 2:

[0068] The user clicks the "Send" button.

[0069] Step 3:

[0070] The terminal takes the rules entered by the user and converts them into JSON format.

[0071] Step 4:

[0072] The terminal sends the converted JSON data to the server as an HTTP POST request.

[0073] Step 5:

[0074] The server receives the request sent from the terminal.

[0075] Step 6:

[0076] The server extracts the new rules from the body of the request.

[0077] Step 7:

[0078] The server inputs the extracted new rules into the generative model and generates a detailed description of the rules.

[0079] Step 8:

[0080] The server checks the new rules against existing rules to detect any inconsistencies or conflicts.

[0081] Step 9:

[0082] The server compiles the generated description and any detected conflicts into a JSON-formatted response.

[0083] Step 10:

[0084] The server sends the generated JSON response to the terminal.

[0085] Step 11:

[0086] The terminal receives the response from the server.

[0087] Step 12:

[0088] The device parses the received JSON response and extracts the generated description and collision information.

[0089] Step 13:

[0090] The terminal displays the extracted explanatory text and conflict information on a user interface.

[0091] Step 14:

[0092] The user checks the displayed content and understands the new rules, their explanations, and conflict information.

[0093] Example 1

[0094] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0095] When managing rules within an organization, there is a need to quickly detect inconsistencies and conflicts with existing rules when introducing new rules and to notify users in an easy-to-understand manner. However, when creating rules and detecting conflicts manually, there is a problem that efficient management is difficult due to the large amount of manual work required. Furthermore, automatically generating explanations for complex rules requires advanced technology, which is difficult to achieve.

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

[0097] In this invention, the server includes means for automatically generating and explaining rules within an organization using a generative model, means for receiving an HTTP POST request and inputting a new rule into the generative model, means for generating an explanation of the new rule using the generative model, means for matching the new rule with existing rules and retrieving information from a database, means for detecting conflicts between the new rule and existing rules, and means for sending the generated explanation and detected conflict information to a terminal as a JSON-formatted response. This makes it possible to automatically detect inconsistencies and conflicts with existing rules when a user introduces a new rule and notify the user quickly and clearly.

[0098] A "generative model" refers to an artificial intelligence algorithm that generates new sentences and explanations based on text data entered by a user.

[0099] "Interface" refers to a screen or device that allows a user to input information into a system.

[0100] An "HTTP POST request" is a type of protocol for sending data to a server when a user inputs a new rule.

[0101] "Database" refers to a system for storing existing rules and for searching and matching them.

[0102] "JSON format" is a format for structuring and expressing data in text format, and is an abbreviation for JavaScript Object Notation.

[0103] "Terminal" refers to an electronic device through which a user accesses and operates the system.

[0104] "Conflict detection" refers to the process of checking for conflicts or inconsistencies between new rules and existing rules.

[0105] "Response" refers to response data sent from the server to the terminal.

[0106] "Parsing" refers to the process of interpreting data received from the server and converting it into an understandable format.

[0107] This invention relates to a system that uses generative AI models to automatically generate and explain rules within an organization. The system has an interface for users to input new rules, matches the new rules with existing rules, detects conflicts, and displays them to the user.

[0108] Server-side configuration

[0109] The server has the following main functions:

[0110] 1. Load the generative model:

[0111] At system startup, the server loads a pre-trained generative AI model, such as a natural language processing model like GPT-3 or BERT, which is used to generate detailed descriptions of new rules.

[0112] 2. Receipt of Request:

[0113] The server receives an HTTP POST request from the device. The request contains the new rules entered by the user in JSON format. For example, if the user enters "prohibit the use of smartphones during meetings," the server proceeds with processing based on this information.

[0114] 3. Explanation generation using generative models:

[0115] The server inputs the new rules it has acquired into a generative AI model, which then generates a detailed explanation based on the rules. For example, if the prompt "Smartphone use is prohibited during meetings" is input into the generative model, the generated explanation will be "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[0116] 4. Collision detection:

[0117] The server checks the new rule against the existing rules, which are loaded from a database, to detect any conflicts. For example, if an existing rule states, "Smartphones are allowed during meetings if there are important communications," the server detects a conflict between the new and old rules.

[0118] 5. Response generation and transmission:

[0119] The server sends the generated description and detected collision information to the device as a JSON-formatted response.

[0120] Terminal configuration

[0121] The terminal has the following main features:

[0122] 1. Providing the user interface:

[0123] The terminal provides an interface for the user to enter new rules, which includes a text box and a submit button. The user enters the new rule through this interface and clicks the submit button.

[0124] 2. Getting user input and generating a request:

[0125] It takes the rules entered by the user, converts them into JSON format, and sends them to the server as an HTTP POST request. For example, if a user enters "prohibit the use of smartphones during meetings," this rule will be sent to the server.

[0126] 3. Receiving and Parsing Responses:

[0127] Receives the response from the server and parses it, extracting the generated description and collision information from the received JSON data.

[0128] 4. View the response:

[0129] The analysis results are displayed to the user. The user can visually see the explanation of the new rule and any conflicts with existing rules. For example, the display might say, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule 'Smartphone use is permitted during meetings if there is an important message.'"

[0130] This system allows users to effectively receive explanations of new rules and identify conflicts with existing rules in advance, which is expected to result in quick and efficient dissemination of rules throughout the organization.

[0131] Prompt Sentence Examples

[0132] "Check the new rule against existing rules and detect conflicts. New rule: 'No smartphones allowed during meetings.'"

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

[0134] Step 1: Loading the Generative Model

[0135] At system startup, the server loads a pre-trained generative AI model, such as a natural language processing model like GPT-3 or BERT. This model is needed to generate explanations for new rules. The input is the model file, and the output is the initialized generative model.

[0136] Step 2: Providing a User Interface

[0137] The terminal provides an interface for the user to enter new rules. This interface includes a text box and a submit button. As the user enters rules, new rules are generated. The input is the user's actions, and the output is the rules entered by the user.

[0138] Step 3: Getting User Input and Creating a Request

[0139] The terminal takes the new rule entered by the user in the text box, converts it to JSON format, and generates an HTTP POST request that is sent to the server, with the input being the user's input data and the output being the JSON formatted request.

[0140] Step 4: Receiving the request

[0141] The server receives an HTTP POST request sent from the device, which contains the new rules entered by the user. The input is the JSON formatted request, and the output is the parsed new rule data.

[0142] Step 5: Generative model for generating explanations

[0143] The server inputs the new rule into the generative model, which then generates a detailed explanation based on the rule. Specifically, the new rule, "No smartphones allowed during meetings," is used as the prompt to generate the explanation, "No smartphones allowed during meetings. This rule is intended to improve productivity." The input is the new rule, and the output is the generated explanation.

[0144] Step 6: Collision detection

[0145] The server loads existing rules from the database to compare the new rule with the existing rules. It checks the new rule against the existing rules to detect inconsistencies and collisions. For example, if the new rule is "Smartphones are prohibited during meetings" and the existing rule is "Smartphones are allowed during meetings if there is an important message," it detects a conflict. The input is the new rule and the existing rule data, and the output is the detected conflict information.

[0146] Step 7: Generate and send a response

[0147] The server compiles the generated explanation and the detected inconsistencies and generates a JSON-formatted response, which is sent to the device. The input is the generated explanation and the detected inconsistencies, and the output is a JSON-formatted response.

[0148] Step 8: Receiving and Parsing the Response

[0149] The terminal receives the response sent from the server and parses it. It extracts the explanation and contradiction information generated from the parsed data. The input is a JSON-formatted response, and the output is the parsed explanation and contradiction information.

[0150] Step 9: View the response

[0151] The device displays the analysis results to the user. The user can see the explanation of the new rule and any conflicts with existing rules. For example, the user receives a notification that reads, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule 'Smartphone use is permitted during meetings if there is an important message.'" The input is the analyzed data, and the output is what is displayed to the user.

[0152] (Application example 1)

[0153] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0154] When introducing new operational and safety rules in existing factories, there is a high possibility that they will conflict with existing rules. This poses a risk of compromising safety and efficiency. Additionally, the process of explaining the new rules and verifying their validity is time-consuming, making it difficult to respond quickly.

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

[0156] In this invention, the server includes means for explaining a new rule using a generative model and detecting inconsistencies therein, means for providing an interface for a user to input the new rule, and means for comparing the new rule with existing rules and detecting conflicts, thereby enabling the user to quickly receive an explanation of the new rule and immediately grasp any inconsistencies with existing rules.

[0157] A "generative model" is an algorithm that uses machine learning or deep learning to learn patterns in documents and data and generate new data and documents.

[0158] A "user" is a person or group that interacts with the system by inputting new rules and constraints.

[0159] An "interface" is the screen or part of the application that the user uses to enter new rules and that is responsible for sending the data to the server.

[0160] "Rules" are the regulations and guidelines that apply within an organization or system.

[0161] "Verification" is the process of comparing new rules with existing rules to identify differences or inconsistencies.

[0162] "Conflict" refers to a situation in which two or more rules contradict each other and are difficult to apply simultaneously.

[0163] "Conflict Information" means data or notifications that indicate conflicts that arise between new rules and existing rules.

[0164] "JSON format" is a lightweight data exchange format for expressing data in text format, and is an abbreviation for JavaScript Object Notation.

[0165] The "server" is the central processing unit that runs the generative model, generates new rule explanations, and detects inconsistencies.

[0166] A "smartphone application" is software that runs on a smartphone and is a program that has functions such as user input, communication with a server, and display of results.

[0167] This invention relates to a system that uses generative models to automatically generate and explain operational and safety rules in factories and detect conflicts with existing rules. This system consists of a smartphone application that allows users to input new rules and check the results, and a server that generates rules and detects conflicts.

[0168] Server configuration and operation

[0169] 1. Load the generative model:

[0170] The server loads and initializes a pre-trained generative model (e.g., GPT-2), which is then used to generate explanations for new rules.

[0171] 2. Receipt of Request:

[0172] The server receives an HTTP POST request sent from the user's device, which contains the new rules entered by the user.

[0173] 3. Explanation generation using generative models:

[0174] The server inputs new rules into the generative model and generates a detailed description of the rules.

[0175] 4. Collision detection:

[0176] The server checks the new rules against existing rules to detect inconsistencies and conflicts, and loads existing rules from a database to perform conflict detection based on the necessary information.

[0177] 5. Response Generation:

[0178] The server compiles the generated explanation and the detected discrepancies and sends it to the device as a JSON-formatted response.

[0179] Terminal configuration and operation

[0180] 1. Providing the user interface:

[0181] The terminal provides an interface for the user to enter new rules, which includes a text box and a submit button.

[0182] 2. Getting user input:

[0183] After the user enters a new rule, the terminal converts the rule into JSON format and sends it to the server as an HTTP POST request.

[0184] 3. View the response:

[0185] The terminal analyzes the response received from the server and displays the generated explanation and contradiction information to the user. As a concrete example, the following input and output are possible:

[0186] Specific examples

[0187] User operations

[0188] The user inputs "The speed of forklifts will be limited in designated areas. The purpose is to prevent accidents" into the user interface of the terminal and clicks the send button.

[0189] Server Processing

[0190] The server receives the request and extracts a new rule: "Limit the speed of forklifts in designated areas. The purpose is to prevent accidents."

[0191] The server inputs this rule into the generative model and generates the explanation, "Forklift speeds are limited in designated areas. This is to prevent accidents."

[0192] The server compares the new rule with existing rules and detects any inconsistencies with the existing rule that "high priority transports are performed at high speed."

[0193] The server generates a JSON response containing the generated explanation and discrepancies and sends it to the device.

[0194] Terminal handling

[0195] The terminal receives the response from the server and analyzes it.

[0196] The terminal displays the analysis results to the user, informing them, "New rule: Limit forklift speeds in designated areas. This is intended to prevent accidents. However, it may conflict with the existing rule: 'High-priority transport must be done at high speeds.'"

[0197] Prompt Sentence Examples

[0198] Example user input:

[0199] "The speed of forklifts is limited in designated areas. The purpose is to prevent accidents."

[0200] The present invention allows new rules to be smoothly introduced within the factory, and makes it possible to maintain safety and efficiency.

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

[0202] Step 1:

[0203] The terminal provides an interface for the user to input new rules. The user enters the new rule in a text box on the interface and clicks the submit button. An example of user input is "Limit the speed of forklifts in designated areas. The purpose is to prevent accidents."

[0204] Step 2:

[0205] The terminal receives the rules entered by the user and converts them into JSON format. The converted data is sent to the server as an HTTP POST request. If the new rule entered is "Limit the speed of forklifts in designated areas. The purpose is to prevent accidents," it is sent to the server as JSON data.

[0206] Step 3:

[0207] The server receives an HTTP POST request and parses the JSON data in the request. It extracts new rules from the parsed data. The server inputs the new rules into the generative model, which then generates an explanation for the rules. For example, the generative model might generate an explanation like, "Forklift speeds are limited in designated areas. This is to prevent accidents."

[0208] Step 4:

[0209] The server loads existing rules from the database to match the new rule with the existing rules. The server compares the new rule with the existing rules to detect inconsistencies and conflicts. For example, if the new rule "Limit the speed of forklifts in designated areas" conflicts with the existing rule "High-priority transport must be done at high speeds," it generates inconsistency information.

[0210] Step 5:

[0211] The server generates a response in JSON format that includes the description of the generated rule and any conflicts. For example, the generated JSON response might read, "Description: Limits the speed of forklifts in the specified area. This is to prevent accidents. Conflicting existing rule: High-priority transport must be done at high speeds."

[0212] Step 6:

[0213] The terminal parses the JSON response received from the server and displays the generated explanation and conflict information to the user. Specifically, it notifies the user that "New rule: Limit the speed of forklifts in designated areas. This is intended to prevent accidents. However, this may conflict with the existing rule 'High-priority transport should be done at high speeds.'"

[0214] By following these steps, the user can accurately input a new rule and quickly understand the rule's description and any inconsistencies with existing rules.

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

[0216] This invention combines an emotion engine with a system that uses generative models to automatically generate and explain rules within an organization. The system has an interface for users to input new rules, matches the new rules with existing rules, detects conflicts, and uses the emotion engine to recognize the user's emotional state and adjust the rule generation and explanation content based on that.

[0217] System configuration

[0218] Server side

[0219] The server has the following main functions:

[0220] 1. Loading the Generative Model: The server loads and initializes a pre-trained generative model, which is used to generate explanations for new rules.

[0221] 2. Receiving the request: The server receives the HTTP POST request sent from the terminal and extracts the new rules entered by the user.

[0222] 3. Explanation generation using the generative model: The server inputs the new rule into the generative model and generates a detailed explanation for the rule.

[0223] 4. Conflict detection: The server checks the new rules against existing rules to detect inconsistencies or conflicts.

[0224] 5. Use of Emotion Engine: The server uses the emotion engine to analyze the user's emotional state and adjusts the explanation and display of the rule based on that information.

[0225] 6. Response generation: The server compiles the generated explanation, conflict information, and adjustments based on emotion information into a JSON-formatted response and sends it to the device.

[0226] Terminal side

[0227] The terminal has the following main features:

[0228] 1. Providing a user interface: The terminal provides an interface for the user to enter new rules, including a text box and a submit button.

[0229] 2. Obtaining user input: The terminal obtains the rules entered by the user and generates a request to send to the server.

[0230] 3. Acquiring emotional information: The device acquires the user's emotions using sensors such as a camera and sends them to the server.

[0231] 4. Displaying the response: The terminal analyzes the response received from the server and displays the generated explanation, conflict information, and adjustments based on the emotion information to the user.

[0232] Specific examples

[0233] User operations

[0234] 1. The user enters "Prohibit use of smartphones during meetings" into the device's user interface and clicks the send button.

[0235] 2. The device converts the rules into JSON format, obtains the user's emotional state, and sends them to the server as an HTTP POST request.

[0236] Server Processing

[0237] 1. The server receives the request and extracts the new rule "prohibit smartphone use during meetings" and emotion data.

[0238] 2. The server inputs this rule into the generative model and generates an explanation: "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[0239] 3. The server compares the new rule with existing rules and detects any conflicts with the existing rule, "Smartphone use is permitted during meetings if there is an important message to be communicated."

[0240] 4. The server uses an emotion engine to analyze the user's emotional state and adjust the content and presentation of the explanation accordingly. For example, if the user is expressing disapproval, the explanation will be softened.

[0241] 5. The server sends a JSON response to the device containing the generated explanation, discrepancies, and information adjusted based on the emotion information.

[0242] Terminal handling

[0243] 1. The device receives the response from the server and analyzes it.

[0244] 2. The device displays the analysis results on the user interface and notifies the user, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule, 'Smartphone use is permitted during meetings if there is important communication to be made.' This rule has been established to improve efficiency across the organization."

[0245] This system allows users to effectively receive explanations of new rules and proactively identify conflicts with existing rules. Furthermore, the system dynamically adjusts the explanation and presentation of rules according to the user's emotional state, making it possible to communicate rules in a more acceptable manner.

[0246] The processing flow will be explained below.

[0247] Step 1:

[0248] The user enters a new rule into the device's user interface, for example, "Do not use smartphones during meetings."

[0249] Step 2:

[0250] The user provides their emotional state (e.g., facial expression or tone of voice) through sensors such as a camera or microphone on the device, which the device then captures as emotion data.

[0251] Step 3:

[0252] The user clicks the "Send" button.

[0253] Step 4:

[0254] The device receives the rules entered by the user and converts them into JSON format, as well as the emotion data.

[0255] Step 5:

[0256] The device sends an HTTP POST request containing the converted rules and emotion data to the server.

[0257] Step 6:

[0258] The server receives the request sent from the terminal.

[0259] Step 7:

[0260] The server extracts the new rules and emotion data from the body of the request.

[0261] Step 8:

[0262] The server inputs the extracted new rule into the generative model and generates a detailed explanation of the rule, for example, "The use of smartphones during meetings is prohibited. This rule is intended to improve productivity."

[0263] Step 9:

[0264] The server checks the new rule against existing rules to detect any inconsistencies or conflicts, such as a conflict with an existing rule that says, "Smartphones are allowed during meetings if there is an important message to be sent."

[0265] Step 10:

[0266] The server uses an emotion engine to analyze the user's emotional state, for example, the emotion engine determines that the user is expressing dislike.

[0267] Step 11:

[0268] The server adjusts the explanation and presentation of the rule based on the results of the emotion engine's analysis. For example, if the user expresses dislike, the explanation will be presented in a gentler way.

[0269] Step 12:

[0270] The server generates a JSON response containing the adjusted description, detected collision information, and emotion information.

[0271] Step 13:

[0272] The server sends the generated JSON response to the device.

[0273] Step 14:

[0274] The terminal receives the response from the server.

[0275] Step 15:

[0276] The device analyzes the received JSON response and extracts adjustments based on the generated description, conflict information, and emotion information.

[0277] Step 16:

[0278] The device displays the extracted explanation, conflict information, and adjustment details on the user interface. For example, it might say, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule, 'Smartphone use is permitted during meetings if there is an important message to be communicated.' This rule was established to improve efficiency across the organization."

[0279] Step 17:

[0280] The user checks the displayed content and understands the new rules and their explanations, as well as the collision information and their adjustments.

[0281] Example 2

[0282] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0283] When formulating new rules within an organization, it was difficult to detect conflicts with existing rules in advance and clearly explain the conflicts. Furthermore, it was not possible to appropriately adjust the explanation based on the user's emotional state, which could lead to user resistance and confusion.

[0284] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for automatically generating and explaining rules within an organization using a generative model, means for providing an interface for a user to input a new rule, means for matching the new rule with existing rules and detecting conflicts, means for analyzing the emotional state of the user using an emotion engine and adjusting the explanation and display method of the generated rule based on the analysis results, and means for displaying the detected conflict information and the adjusted explanation of the rule to the user. This makes it possible to automatically and effectively generate new rules and explain conflicts with existing rules, and further to adjust the content of the explanation according to the emotional state of the user.

[0285] A "generative model" is an artificial intelligence technique that uses pre-trained algorithms to generate new rules and text.

[0286] "Organizational rules" refer to the rules and guidelines that employees and members must follow within an organization.

[0287] "Interface" refers to the means of providing a screen and input methods to enable interaction between a user and a system.

[0288] "Conflict detection" refers to the process of comparing new rules with existing rules to identify contradictions or inconsistencies.

[0289] An "emotion engine" refers to artificial intelligence technology for analyzing a user's emotional state, and has the ability to read emotions primarily from facial expressions and tone of voice.

[0290] "Emotional state" refers to a user's psychological response or emotional state at a particular moment.

[0291] "JSON format" stands for JavaScript Object Notation and refers to a text-based format for structuring and transferring data.

[0292] An "HTTP POST request" is one of the Internet protocols and refers to a request format for sending data to a server.

[0293] The present invention combines an emotion engine with a system that uses generative models to automatically generate and explain rules within an organization. The system provides an interface for users to input new rules, matches the new rules with existing rules to detect conflicts, and uses the emotion engine to recognize the user's emotional state and adjust the rule generation and explanation content accordingly.

[0294] Specific processing on the server side

[0295] 1. Load the generative model:

[0296] The server loads and initializes a pre-trained generative model (e.g., a general generative AI model), which is used to generate explanations for new rules, and deploys the model in the server's memory and makes it accessible through an API interface.

[0297] 2. Receipt of Request:

[0298] The server receives an HTTP POST request from the device. This request contains the new rules entered by the user in JSON format. For example, if the user enters "prohibit the use of smartphones during meetings," the server receives a request containing that rule.

[0299] 3. Explanation generation using generative models:

[0300] The server inputs the new rule into the generative model and generates a detailed explanation for the rule. The generative model generates an explanation by providing a prompt such as "New rule: XX. The reason is...". An explanation such as "Smartphone use is prohibited during meetings. This rule is intended to improve productivity" can be generated.

[0301] 4. Collision detection:

[0302] The server compares the new rule with existing rules to detect any inconsistencies or conflicts. For example, it analyzes the inconsistencies with an existing rule such as "Smartphones are allowed during meetings if there is an important message to be sent."

[0303] 5. Use of Emotion Engine:

[0304] The server uses an emotion engine (e.g., general emotion recognition software) to analyze the user's emotional data. Based on this data, it adjusts the rule explanation and display method. If the user shows resentment, it changes the wording to a softer one.

[0305] 6. Response Generation:

[0306] The server compiles the generated explanation, conflict information between the new rule and the existing rule, and information adjusted based on the emotional state as a JSON response, and sends this response to the device via HTTP POST.

[0307] Specific processing on the terminal side

[0308] 1. Providing the user interface:

[0309] The terminal provides an interface (e.g., a web page with text boxes and a submit button) for the user to enter new rules. Arrange the fields to make it easy for the user to enter them.

[0310] 2. Getting user input:

[0311] The terminal takes the rules entered by the user in the text box and converts them into JSON format, which includes metadata such as the rule content and timestamp.

[0312] 3. Acquiring emotional information:

[0313] The device uses cameras and other sensors to capture user emotion data, for example, by using facial recognition technology to analyze emotions from the user's facial expressions and add the data to a JSON format.

[0314] 4. View the response:

[0315] The device analyzes the response received from the server and displays the generated explanation, conflict information between the new rule and the existing rule, and content adjusted based on the user's emotional state. The information is displayed visually in a pop-up or modal window.

[0316] Specific examples

[0317] User operations

[0318] 1. The user enters "Prohibit smartphone use during meetings" into the device interface and clicks the send button.

[0319] 2. The device converts the rules entered by the user into JSON format and sends it to the server as an HTTP POST request along with the emotion data acquired by the facial recognition sensor.

[0320] Server Processing

[0321] 1. The server receives the request and extracts the new rule "prohibit smartphone use during meetings" and emotion data.

[0322] 2. The server inputs this rule into the generative model and generates the explanation, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[0323] 3. The server compares the new rule with existing rules and detects any inconsistencies with the existing rule, "Smartphones are allowed during meetings if there is an important message to be communicated."

[0324] 4. The server uses an emotion engine to analyze the user's emotional state, and if the user is showing resentment, adjusts the statement to a softer one, such as "The new rules are necessary to improve the efficiency of the entire organization."

[0325] 5. The server sends a JSON response to the device, including the generated description, collision points, and information adjusted based on emotion information.

[0326] Terminal handling

[0327] 1. The device receives the response from the server and analyzes it.

[0328] 2. The device displays the analysis results on the user interface and notifies users, for example, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule, 'Smartphone use is permitted during meetings if there is an important message to be communicated.' This rule has been established to improve efficiency across the organization."

[0329] The system allows users to receive detailed explanations of new rules and proactively identify conflicts with existing rules. Furthermore, the explanations are tailored to the user's emotional state, making it possible to present rules in a more acceptable format.

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

[0331] Step 1: Loading the Generative Model

[0332] The server loads pre-trained generative models and makes them accessible through an API interface. As input, it receives the file path and configuration information of the required model. The server loads this in memory and initializes it. As output, the generative model is ready to use.

[0333] Step 2: Receiving the request

[0334] The device provides an interface (e.g., a text box) where the user enters a new rule. The user initiates the request by entering "ban smartphones during meetings" and clicking the submit button. The server receives an HTTP POST request from the device. The input contains the new rule entered by the user in JSON format. The server parses the request and extracts the content of the new rule. The output is the text of the new rule.

[0335] Step 3: Generative model for generating explanations

[0336] The server inputs the new rule text into the generative model and generates a detailed explanation for that rule. The generative model generates an explanation by giving a prompt such as "New rule: XX. The reason is...". The text of the new rule is given as input, and the generated explanation is obtained as output.

[0337] Step 4: Collision detection

[0338] The server checks the new rule against existing rules to find inconsistencies and conflicts. Existing rules are loaded from a database. As input, the text of the new rule and the data of the existing rule are given. The server compares them and identifies conflicts. As output, it gets a list of conflicts.

[0339] Step 5: Use the Emotion Engine

[0340] The device uses a camera and other sensors to capture the user's emotional data and sends it to the server. The server then uses an emotion engine to analyze the user's emotional state. The user's emotional data is given as input, and the analysis results are obtained as output, which are used to adjust the explanation.

[0341] Step 6: Response Generation

[0342] The server compiles the generated description, conflict information between new rules and existing rules, and information adjusted based on the emotional state, and generates a response in JSON format. The input is the generated description, a list of conflict points, and the emotion analysis results. The server integrates these and generates response data as output, which is sent to the terminal as an HTTP response.

[0343] Step 7: View the response

[0344] The device parses the JSON response received from the server and displays information to the user in a visually understandable way. The response data received from the server is given as input. The device parses it and checks the generated explanation, conflict information between new rules and existing rules, and adjustments based on the emotional state. The output is the content displayed in the user interface.

[0345] (Application example 2)

[0346] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0347] Typically, creating and explaining rules within an organization is done manually, which requires a great deal of effort and time. Furthermore, when contradictions or conflicts arise between rules, the process of detecting and resolving them is complicated. Explaining and displaying rules in a way that is emotionally receptive to users is even more difficult. In particular, virtual stores are used by a diverse range of users, so individual, appropriate responses are required. The objective of this invention is to solve these problems and provide a system that automatically generates and explains rules and optimally displays them, taking into account the user's emotional state.

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

[0349] In this invention, the server includes: means for automatically generating and explaining rules within an organization using a generative model; means for providing an interface for a user to input a new rule; means for comparing the new rule with existing rules and detecting conflicts; means for displaying detected conflict information to the user; means for recognizing the user's emotional state using an emotion engine and adjusting the explanation and display content based on the emotional state; and means for adjusting prompt sentences based on the user's emotional state when generating a new rule explanation. This makes it possible to automatically and dynamically explain and display rules to a variety of users and provide optimal responses according to their emotions.

[0350] A "generative model" is an artificial intelligence technology that generates new information based on previously learned data.

[0351] "Organizational rules" refer to instructions and regulations set within a particular organization or group.

[0352] An "emotion engine" is a system that recognizes a user's emotional state by analyzing their facial expressions, voice, and other data.

[0353] An "interface" is the means or medium through which a user accesses and operates a system.

[0354] "Matching" is the act of comparing two or more pieces of data to see if they match.

[0355] Detecting a "conflict" means discovering whether a new rule that is generated contradicts an existing rule.

[0356] "Adjust" refers to changing or optimizing content for specific conditions or circumstances.

[0357] A "prompt sentence" is a basic sentence or instruction that serves as input to a generative model.

[0358] This invention is a system that automatically generates and explains rules within an organization using a generative model and an emotion engine. The system provides an interface for inputting new rules, generates detailed explanations using the generative model, detects conflicts with existing rules, and adjusts the explanations and display content based on the user's emotional state.

[0359] Server-side configuration

[0360] The server has the following main functions:

[0361] 1. Loading a Generative Model: The server loads and initializes a pre-trained generative model (e.g., OpenAI's API). This generative model receives a prompt to explain the new rule as input and generates a detailed explanation.

[0362] 2. Receiving a request: The server receives the HTTP POST request sent from the device and extracts the new rules and emotion data entered by the user.

[0363] 3. Explanation generation: The server inputs the new rule into the generative model and generates a detailed explanation based on the user's sentiment. For example, if a user inputs "Smartphone use is prohibited during meetings," the generative model generates the explanation "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[0364] 4. Conflict detection: The server loads the new rule and the existing rule from the database and compares them to detect any inconsistencies or conflicts. For example, if an existing rule states, "Smartphones are allowed during meetings if there are important communications," a conflict will be detected.

[0365] 5. Use of Emotion Engine: The server uses an emotion engine (e.g., EmotionEngine) to analyze the user's emotional state and adjust the generated explanation based on that information. For example, if the user expresses dislike, it adds the explanation, "In addition, this rule was established to reduce the burden on the user."

[0366] 6. Response generation: The server compiles the generated explanation, contradiction information, and adjustments based on emotion information into a JSON-formatted response and sends it to the device.

[0367] Terminal configuration

[0368] The terminal has the following main features:

[0369] 1. Providing an interface: The terminal provides an interface (e.g., a text box and a submit button) for the user to input new rules.

[0370] 2. Obtaining user input: The device obtains the rules entered by the user and analyzes the user's emotional state using sensors such as a camera.

[0371] 3. Data transmission: The device converts the new rules and emotion information into JSON format and sends it to the server as an HTTP POST request.

[0372] 4. Displaying the response: The terminal analyzes the response received from the server and displays the generated explanation, conflict information, and adjustments based on the emotion information to the user.

[0373] Specific example explanation

[0374] The user enters "Smartphone use is prohibited during meetings" into the device interface and clicks the send button. The device converts the rule into JSON format, obtains the user's emotional state, and sends them to the server as an HTTP POST request. The server receives the request and extracts the new rule "Smartphone use is prohibited during meetings" and emotional data. This rule is input into the generative model, and an explanation is generated: "Smartphone use is prohibited during meetings. This rule is intended to improve productivity." A contradiction with the existing rule "Smartphone use is permitted during meetings if there is an important message to be communicated." The emotion engine also analyzes the user's emotional state, and if it is determined to be "negative," a correction is made: "In addition, this rule has been established to reduce the user's burden." Finally, the generated explanation and contradictions are sent to the device in JSON format and displayed to the user.

[0375] Prompt Sentence Examples

[0376] Please generate detailed explanations for the following rules:

[0377] ---

[0378] Rule: "No smartphones allowed during meetings."

[0379] ---

[0380] Detailed Description:

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

[0382] Step 1:

[0383] Getting User Input

[0384] The user inputs a new rule into the device interface and clicks the submit button. The input rule is "prohibit the use of smartphones during meetings." At the same time, the device's camera captures the user's emotional data. The input data and emotional data are obtained.

[0385] Step 2:

[0386] Data transmission

[0387] The device converts the acquired new rules and emotion data into JSON format and sends it to the server as an HTTP POST request. The request content includes the new rules and emotion data. The input data is the new rules and emotion data, and the output data is the HTTP request.

[0388] Step 3:

[0389] Receipt of request

[0390] The server receives the HTTP POST request, analyzes the content, extracts new rules and emotion data, and stores them in the respective variables. The input data is the HTTP request, and the output data is the new rules and emotion data.

[0391] Step 4:

[0392] Using generative models

[0393] The server inputs a prompt and a new rule into a pre-loaded generative model (e.g., OpenAI's API). Prompt: "The use of smartphones is prohibited during meetings." The generative model generates a detailed explanation based on this prompt. The explanation is "The use of smartphones is prohibited during meetings. This rule is intended to improve productivity." The input data is the prompt and the new rule, and the output data is the explanation.

[0394] Step 5:

[0395] Collision Detection

[0396] The server loads existing rules from the database and compares them with the new rule. For example, if an existing rule states, "Smartphones are allowed during meetings if there is an important message," the server detects the inconsistency. The input data is the new rule and the existing rule, and the output data is the inconsistency information.

[0397] Step 6:

[0398] Using the Emotion Engine

[0399] The server uses an emotion engine (e.g., EmotionEngine) to analyze the user's emotion data. If the emotion is recognized as "negative," it adds a note to the generated explanation saying, "This rule was established to reduce the burden on the user." The input data is the emotion data, and the output data is the corrected explanation.

[0400] Step 7:

[0401] Response Generation

[0402] The server generates a final response based on the generated description, contradiction information, and emotion information. The response is sent to the terminal in JSON format. The input data are the generated description, contradiction information, and emotion information, and the output data is the JSON format response.

[0403] Step 8:

[0404] Viewing the response

[0405] The terminal parses the JSON response received from the server and displays it to the user. The user can then check the generated explanation for any discrepancies between the explanation and existing rules, as well as supplementary explanations based on emotions. The input data is the JSON response, and the output data is displayed on the user interface.

[0406] The specific processing unit 290 transmits the result of the specific processing to the smart device 14. In the smart device 14, the control unit 46A causes the output device 40 to output the result of the specific processing. The microphone 38B acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

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

[0408] In the above embodiment, an example in which the specific process is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific process may be performed by the smart device 14.

[0409] [Second embodiment]

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

[0411] 3, the data processing system 210 includes the data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

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

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

[0414] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

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

[0416] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0417] Fig. 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Fig. 4, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0418] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

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

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

[0421] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal."

[0422] The present invention relates to a system that automatically generates and explains rules within an organization using a generative model. This system has an interface for users to input new rules, compares the new rules with existing rules, detects conflicts, and displays them to the user. Specific embodiments for implementing the present invention are described below.

[0423] System configuration

[0424] Server side

[0425] The server has the following main functions:

[0426] 1. Load Generative Model: The server loads and initializes a pre-trained generative model, which is used to generate explanations for new rules.

[0427] 2. Receiving a request: The server receives an HTTP POST request sent from the terminal, which includes the new rules entered by the user.

[0428] 3. Explanation generation using the generative model: The server inputs a new rule into the generative model and generates a detailed explanation for that rule.

[0429] 4. Conflict Detection: The server detects possible inconsistencies or conflicts between new rules and existing rules.

[0430] 5. Response generation: The server compiles the generated explanation and detected conflict information and sends it to the terminal as a JSON-formatted response.

[0431] Terminal side

[0432] The terminal has the following main features:

[0433] 1. Providing a user interface: The terminal provides an interface for the user to enter new rules, including a text box and a submit button.

[0434] 2. Obtaining user input: The terminal obtains the rules entered by the user and generates a request to send to the server.

[0435] 3. Displaying the response: The terminal analyzes the response received from the server and displays the generated explanation and conflict information to the user.

[0436] Specific examples

[0437] User operations

[0438] 1. The user enters "Prohibit use of smartphones during meetings" into the device's user interface and clicks the send button.

[0439] 2. The device converts the rules into JSON format and sends it to the server as an HTTP POST request.

[0440] Server Processing

[0441] 1. The server receives the request and extracts a new rule: "Do not use smartphones during meetings."

[0442] 2. The server inputs this rule into the generative model and generates an explanation: "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[0443] 3. The server compares the new rule with existing rules and detects any conflicts with the existing rule, "Smartphone use is permitted during meetings if there is an important message to be communicated."

[0444] 4. The server generates a JSON response containing the generated explanation and discrepancies and sends it to the device.

[0445] Terminal handling

[0446] 1. The terminal receives the response from the server and analyzes it.

[0447] 2. The device displays the analysis results to the user and notifies them, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule: Smartphone use is permitted during meetings if there is an important message to be communicated."

[0448] This system allows users to effectively receive explanations of new rules and proactively identify conflicts with existing rules, resulting in fast and efficient rule dissemination throughout the organization.

[0449] The processing flow will be explained below.

[0450] Step 1:

[0451] The user enters a new rule into the device's user interface, for example, "Do not use smartphones during meetings."

[0452] Step 2:

[0453] The user clicks the "Send" button.

[0454] Step 3:

[0455] The terminal takes the rules entered by the user and converts them into JSON format.

[0456] Step 4:

[0457] The terminal sends the converted JSON data to the server as an HTTP POST request.

[0458] Step 5:

[0459] The server receives the request sent from the terminal.

[0460] Step 6:

[0461] The server extracts the new rules from the body of the request.

[0462] Step 7:

[0463] The server inputs the extracted new rules into the generative model and generates a detailed description of the rules.

[0464] Step 8:

[0465] The server checks the new rules against existing rules to detect any inconsistencies or conflicts.

[0466] Step 9:

[0467] The server compiles the generated description and any detected conflicts into a JSON-formatted response.

[0468] Step 10:

[0469] The server sends the generated JSON response to the terminal.

[0470] Step 11:

[0471] The terminal receives the response from the server.

[0472] Step 12:

[0473] The device parses the received JSON response and extracts the generated description and collision information.

[0474] Step 13:

[0475] The terminal displays the extracted explanatory text and conflict information on a user interface.

[0476] Step 14:

[0477] The user checks the displayed content and understands the new rules, their explanations, and conflict information.

[0478] Example 1

[0479] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0480] When managing rules within an organization, there is a need to quickly detect inconsistencies and conflicts with existing rules when introducing new rules and to notify users in an easy-to-understand manner. However, when creating rules and detecting conflicts manually, there is a problem that efficient management is difficult due to the large amount of manual work required. Furthermore, automatically generating explanations for complex rules requires advanced technology, which is difficult to achieve.

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

[0482] In this invention, the server includes means for automatically generating and explaining rules within an organization using a generative model, means for receiving an HTTP POST request and inputting a new rule into the generative model, means for generating an explanation of the new rule using the generative model, means for matching the new rule with existing rules and retrieving information from a database, means for detecting conflicts between the new rule and existing rules, and means for sending the generated explanation and detected conflict information to a terminal as a JSON-formatted response. This makes it possible to automatically detect inconsistencies and conflicts with existing rules when a user introduces a new rule and notify the user quickly and clearly.

[0483] A "generative model" refers to an artificial intelligence algorithm that generates new sentences and explanations based on text data entered by a user.

[0484] "Interface" refers to a screen or device that allows a user to input information into a system.

[0485] An "HTTP POST request" is a type of protocol for sending data to a server when a user inputs a new rule.

[0486] "Database" refers to a system for storing existing rules and for searching and matching them.

[0487] "JSON format" is a format for structuring and expressing data in text format, and is an abbreviation for JavaScript Object Notation.

[0488] "Terminal" refers to an electronic device through which a user accesses and operates the system.

[0489] "Conflict detection" refers to the process of checking for conflicts or inconsistencies between new rules and existing rules.

[0490] "Response" refers to response data sent from the server to the terminal.

[0491] "Parsing" refers to the process of interpreting data received from the server and converting it into an understandable format.

[0492] This invention relates to a system that uses generative AI models to automatically generate and explain rules within an organization. The system has an interface for users to input new rules, matches the new rules with existing rules, detects conflicts, and displays them to the user.

[0493] Server-side configuration

[0494] The server has the following main functions:

[0495] 1. Load the generative model:

[0496] At system startup, the server loads a pre-trained generative AI model, such as a natural language processing model like GPT-3 or BERT, which is used to generate detailed descriptions of new rules.

[0497] 2. Receipt of Request:

[0498] The server receives an HTTP POST request from the device. The request contains the new rules entered by the user in JSON format. For example, if the user enters "prohibit the use of smartphones during meetings," the server proceeds with processing based on this information.

[0499] 3. Explanation generation using generative models:

[0500] The server inputs the new rules it has acquired into a generative AI model, which then generates a detailed explanation based on the rules. For example, if the prompt "Smartphone use is prohibited during meetings" is input into the generative model, the generated explanation will be "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[0501] 4. Collision detection:

[0502] The server checks the new rule against the existing rules, which are loaded from a database, to detect any conflicts. For example, if an existing rule states, "Smartphones are allowed during meetings if there are important communications," the server detects a conflict between the new and old rules.

[0503] 5. Response generation and transmission:

[0504] The server sends the generated description and detected collision information to the device as a JSON-formatted response.

[0505] Terminal configuration

[0506] The terminal has the following main features:

[0507] 1. Providing the user interface:

[0508] The terminal provides an interface for the user to enter new rules, which includes a text box and a submit button. The user enters the new rule through this interface and clicks the submit button.

[0509] 2. Getting user input and generating a request:

[0510] It takes the rules entered by the user, converts them into JSON format, and sends them to the server as an HTTP POST request. For example, if a user enters "prohibit the use of smartphones during meetings," this rule will be sent to the server.

[0511] 3. Receiving and Parsing Responses:

[0512] Receives the response from the server and parses it, extracting the generated description and collision information from the received JSON data.

[0513] 4. View the response:

[0514] The analysis results are displayed to the user. The user can visually see the explanation of the new rule and any conflicts with existing rules. For example, the display might say, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule 'Smartphone use is permitted during meetings if there is an important message.'"

[0515] This system allows users to effectively receive explanations of new rules and identify conflicts with existing rules in advance, which is expected to result in quick and efficient dissemination of rules throughout the organization.

[0516] Prompt Sentence Examples

[0517] "Check the new rule against existing rules and detect conflicts. New rule: 'No smartphones allowed during meetings.'"

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

[0519] Step 1: Loading the Generative Model

[0520] At system startup, the server loads a pre-trained generative AI model, such as a natural language processing model like GPT-3 or BERT. This model is needed to generate explanations for new rules. The input is the model file, and the output is the initialized generative model.

[0521] Step 2: Providing a User Interface

[0522] The terminal provides an interface for the user to enter new rules. This interface includes a text box and a submit button. As the user enters rules, new rules are generated. The input is the user's actions, and the output is the rules entered by the user.

[0523] Step 3: Getting User Input and Creating a Request

[0524] The terminal takes the new rule entered by the user in the text box, converts it to JSON format, and generates an HTTP POST request that is sent to the server, with the input being the user's input data and the output being the JSON formatted request.

[0525] Step 4: Receiving the request

[0526] The server receives an HTTP POST request sent from the device, which contains the new rules entered by the user. The input is the JSON formatted request, and the output is the parsed new rule data.

[0527] Step 5: Generative model for generating explanations

[0528] The server inputs the new rule into the generative model, which then generates a detailed explanation based on the rule. Specifically, the new rule, "No smartphones allowed during meetings," is used as the prompt to generate the explanation, "No smartphones allowed during meetings. This rule is intended to improve productivity." The input is the new rule, and the output is the generated explanation.

[0529] Step 6: Collision detection

[0530] The server loads existing rules from the database to compare the new rule with the existing rules. It checks the new rule against the existing rules to detect inconsistencies and collisions. For example, if the new rule is "Smartphones are prohibited during meetings" and the existing rule is "Smartphones are allowed during meetings if there is an important message," it detects a conflict. The input is the new rule and the existing rule data, and the output is the detected conflict information.

[0531] Step 7: Generate and send a response

[0532] The server compiles the generated explanation and the detected inconsistencies and generates a JSON-formatted response, which is sent to the device. The input is the generated explanation and the detected inconsistencies, and the output is a JSON-formatted response.

[0533] Step 8: Receiving and Parsing the Response

[0534] The terminal receives the response sent from the server and parses it. It extracts the explanation and contradiction information generated from the parsed data. The input is a JSON-formatted response, and the output is the parsed explanation and contradiction information.

[0535] Step 9: View the response

[0536] The device displays the analysis results to the user. The user can see the explanation of the new rule and any conflicts with existing rules. For example, the user receives a notification that reads, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule 'Smartphone use is permitted during meetings if there is an important message.'" The input is the analyzed data, and the output is what is displayed to the user.

[0537] (Application example 1)

[0538] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0539] When introducing new operational and safety rules in existing factories, there is a high possibility that they will conflict with existing rules. This poses a risk of compromising safety and efficiency. Additionally, the process of explaining the new rules and verifying their validity is time-consuming, making it difficult to respond quickly.

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

[0541] In this invention, the server includes means for explaining a new rule using a generative model and detecting inconsistencies therein, means for providing an interface for a user to input the new rule, and means for comparing the new rule with existing rules and detecting conflicts, thereby enabling the user to quickly receive an explanation of the new rule and immediately grasp any inconsistencies with existing rules.

[0542] A "generative model" is an algorithm that uses machine learning or deep learning to learn patterns in documents and data and generate new data and documents.

[0543] A "user" is a person or group that interacts with the system by inputting new rules and constraints.

[0544] An "interface" is the screen or part of the application that the user uses to enter new rules and that is responsible for sending the data to the server.

[0545] "Rules" are the regulations and guidelines that apply within an organization or system.

[0546] "Verification" is the process of comparing new rules with existing rules to identify differences or inconsistencies.

[0547] "Conflict" refers to a situation in which two or more rules contradict each other and are difficult to apply simultaneously.

[0548] "Conflict Information" means data or notifications that indicate conflicts that arise between new rules and existing rules.

[0549] "JSON format" is a lightweight data exchange format for expressing data in text format, and is an abbreviation for JavaScript Object Notation.

[0550] The "server" is the central processing unit that runs the generative model, generates new rule explanations, and detects inconsistencies.

[0551] A "smartphone application" is software that runs on a smartphone and is a program that has functions such as user input, communication with a server, and display of results.

[0552] This invention relates to a system that uses generative models to automatically generate and explain operational and safety rules in factories and detect conflicts with existing rules. This system consists of a smartphone application that allows users to input new rules and check the results, and a server that generates rules and detects conflicts.

[0553] Server configuration and operation

[0554] 1. Load the generative model:

[0555] The server loads and initializes a pre-trained generative model (e.g., GPT-2), which is then used to generate explanations for new rules.

[0556] 2. Receipt of Request:

[0557] The server receives an HTTP POST request sent from the user's device, which contains the new rules entered by the user.

[0558] 3. Explanation generation using generative models:

[0559] The server inputs new rules into the generative model and generates a detailed description of the rules.

[0560] 4. Collision detection:

[0561] The server checks the new rules against existing rules to detect inconsistencies and conflicts, and loads existing rules from a database to perform conflict detection based on the necessary information.

[0562] 5. Response Generation:

[0563] The server compiles the generated explanation and the detected discrepancies and sends it to the device as a JSON-formatted response.

[0564] Terminal configuration and operation

[0565] 1. Providing the user interface:

[0566] The terminal provides an interface for the user to enter new rules, which includes a text box and a submit button.

[0567] 2. Getting user input:

[0568] After the user enters a new rule, the terminal converts the rule into JSON format and sends it to the server as an HTTP POST request.

[0569] 3. View the response:

[0570] The terminal analyzes the response received from the server and displays the generated explanation and contradiction information to the user. As a concrete example, the following input and output are possible:

[0571] Specific examples

[0572] User operations

[0573] The user inputs "The speed of forklifts will be limited in designated areas. The purpose is to prevent accidents" into the user interface of the terminal and clicks the send button.

[0574] Server Processing

[0575] The server receives the request and extracts a new rule: "Limit the speed of forklifts in designated areas. The purpose is to prevent accidents."

[0576] The server inputs this rule into the generative model and generates the explanation, "Forklift speeds are limited in designated areas. This is to prevent accidents."

[0577] The server compares the new rule with existing rules and detects any inconsistencies with the existing rule that "high priority transports are performed at high speed."

[0578] The server generates a JSON response containing the generated explanation and discrepancies and sends it to the device.

[0579] Terminal handling

[0580] The terminal receives the response from the server and analyzes it.

[0581] The terminal displays the analysis results to the user, informing them, "New rule: Limit forklift speeds in designated areas. This is intended to prevent accidents. However, it may conflict with the existing rule: 'High-priority transport must be done at high speeds.'"

[0582] Prompt Sentence Examples

[0583] Example user input:

[0584] "The speed of forklifts is limited in designated areas. The purpose is to prevent accidents."

[0585] The present invention allows new rules to be smoothly introduced within the factory, and makes it possible to maintain safety and efficiency.

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

[0587] Step 1:

[0588] The terminal provides an interface for the user to input new rules. The user enters the new rule in a text box on the interface and clicks the submit button. An example of user input is "Limit the speed of forklifts in designated areas. The purpose is to prevent accidents."

[0589] Step 2:

[0590] The terminal receives the rules entered by the user and converts them into JSON format. The converted data is sent to the server as an HTTP POST request. If the new rule entered is "Limit the speed of forklifts in designated areas. The purpose is to prevent accidents," it is sent to the server as JSON data.

[0591] Step 3:

[0592] The server receives an HTTP POST request and parses the JSON data in the request. It extracts new rules from the parsed data. The server inputs the new rules into the generative model, which then generates an explanation for the rules. For example, the generative model might generate an explanation like, "Forklift speeds are limited in designated areas. This is to prevent accidents."

[0593] Step 4:

[0594] The server loads existing rules from the database to match the new rule with the existing rules. The server compares the new rule with the existing rules to detect inconsistencies and conflicts. For example, if the new rule "Limit the speed of forklifts in designated areas" conflicts with the existing rule "High-priority transport must be done at high speeds," it generates inconsistency information.

[0595] Step 5:

[0596] The server generates a response in JSON format that includes the description of the generated rule and any conflicts. For example, the generated JSON response might read, "Description: Limits the speed of forklifts in the specified area. This is to prevent accidents. Conflicting existing rule: High-priority transport must be done at high speeds."

[0597] Step 6:

[0598] The terminal parses the JSON response received from the server and displays the generated explanation and conflict information to the user. Specifically, it notifies the user that "New rule: Limit the speed of forklifts in designated areas. This is intended to prevent accidents. However, this may conflict with the existing rule 'High-priority transport should be done at high speeds.'"

[0599] By following these steps, the user can accurately input a new rule and quickly understand the rule's description and any inconsistencies with existing rules.

[0600] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0601] This invention combines an emotion engine with a system that uses generative models to automatically generate and explain rules within an organization. The system has an interface for users to input new rules, matches the new rules with existing rules, detects conflicts, and uses the emotion engine to recognize the user's emotional state and adjust the rule generation and explanation content based on that.

[0602] System configuration

[0603] Server side

[0604] The server has the following main functions:

[0605] 1. Loading the Generative Model: The server loads and initializes a pre-trained generative model, which is used to generate explanations for new rules.

[0606] 2. Receiving the request: The server receives the HTTP POST request sent from the terminal and extracts the new rules entered by the user.

[0607] 3. Explanation generation using the generative model: The server inputs the new rule into the generative model and generates a detailed explanation for the rule.

[0608] 4. Conflict detection: The server checks the new rules against existing rules to detect inconsistencies or conflicts.

[0609] 5. Use of Emotion Engine: The server uses the emotion engine to analyze the user's emotional state and adjusts the explanation and display of the rule based on that information.

[0610] 6. Response generation: The server compiles the generated explanation, conflict information, and adjustments based on emotion information into a JSON-formatted response and sends it to the device.

[0611] Terminal side

[0612] The terminal has the following main features:

[0613] 1. Providing a user interface: The terminal provides an interface for the user to enter new rules, including a text box and a submit button.

[0614] 2. Obtaining user input: The terminal obtains the rules entered by the user and generates a request to send to the server.

[0615] 3. Acquiring emotional information: The device acquires the user's emotions using sensors such as a camera and sends them to the server.

[0616] 4. Displaying the response: The terminal analyzes the response received from the server and displays the generated explanation, conflict information, and adjustments based on the emotion information to the user.

[0617] Specific examples

[0618] User operations

[0619] 1. The user enters "Prohibit use of smartphones during meetings" into the device's user interface and clicks the send button.

[0620] 2. The device converts the rules into JSON format, obtains the user's emotional state, and sends them to the server as an HTTP POST request.

[0621] Server Processing

[0622] 1. The server receives the request and extracts the new rule "prohibit smartphone use during meetings" and emotion data.

[0623] 2. The server inputs this rule into the generative model and generates an explanation: "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[0624] 3. The server compares the new rule with existing rules and detects any conflicts with the existing rule, "Smartphone use is permitted during meetings if there is an important message to be communicated."

[0625] 4. The server uses an emotion engine to analyze the user's emotional state and adjust the content and presentation of the explanation accordingly. For example, if the user is expressing disapproval, the explanation will be softened.

[0626] 5. The server sends a JSON response to the device containing the generated explanation, discrepancies, and information adjusted based on the emotion information.

[0627] Terminal handling

[0628] 1. The device receives the response from the server and analyzes it.

[0629] 2. The device displays the analysis results on the user interface and notifies the user, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule, 'Smartphone use is permitted during meetings if there is important communication to be made.' This rule has been established to improve efficiency across the organization."

[0630] This system allows users to effectively receive explanations of new rules and proactively identify conflicts with existing rules. Furthermore, the system dynamically adjusts the explanation and presentation of rules according to the user's emotional state, making it possible to communicate rules in a more acceptable manner.

[0631] The processing flow will be explained below.

[0632] Step 1:

[0633] The user enters a new rule into the device's user interface, for example, "Do not use smartphones during meetings."

[0634] Step 2:

[0635] The user provides their emotional state (e.g., facial expression or tone of voice) through sensors such as a camera or microphone on the device, which the device then captures as emotion data.

[0636] Step 3:

[0637] The user clicks the "Send" button.

[0638] Step 4:

[0639] The device receives the rules entered by the user and converts them into JSON format, as well as the emotion data.

[0640] Step 5:

[0641] The device sends an HTTP POST request containing the converted rules and emotion data to the server.

[0642] Step 6:

[0643] The server receives the request sent from the terminal.

[0644] Step 7:

[0645] The server extracts the new rules and emotion data from the body of the request.

[0646] Step 8:

[0647] The server inputs the extracted new rule into the generative model and generates a detailed explanation of the rule, for example, "The use of smartphones during meetings is prohibited. This rule is intended to improve productivity."

[0648] Step 9:

[0649] The server checks the new rule against existing rules to detect any inconsistencies or conflicts, such as a conflict with an existing rule that says, "Smartphones are allowed during meetings if there is an important message to be sent."

[0650] Step 10:

[0651] The server uses an emotion engine to analyze the user's emotional state, for example, the emotion engine determines that the user is expressing dislike.

[0652] Step 11:

[0653] The server adjusts the explanation and presentation of the rule based on the results of the emotion engine's analysis. For example, if the user expresses dislike, the explanation will be presented in a gentler way.

[0654] Step 12:

[0655] The server generates a JSON response containing the adjusted description, detected collision information, and emotion information.

[0656] Step 13:

[0657] The server sends the generated JSON response to the device.

[0658] Step 14:

[0659] The terminal receives the response from the server.

[0660] Step 15:

[0661] The device analyzes the received JSON response and extracts adjustments based on the generated description, conflict information, and emotion information.

[0662] Step 16:

[0663] The device displays the extracted explanation, conflict information, and adjustment details on the user interface. For example, it might say, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule, 'Smartphone use is permitted during meetings if there is an important message to be communicated.' This rule was established to improve efficiency across the organization."

[0664] Step 17:

[0665] The user checks the displayed content and understands the new rules and their explanations, as well as the collision information and their adjustments.

[0666] Example 2

[0667] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0668] When formulating new rules within an organization, it was difficult to detect conflicts with existing rules in advance and clearly explain the conflicts. Furthermore, it was not possible to appropriately adjust the explanation based on the user's emotional state, which could lead to user resistance and confusion.

[0669] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for automatically generating and explaining rules within an organization using a generative model, means for providing an interface for a user to input a new rule, means for matching the new rule with existing rules and detecting conflicts, means for analyzing the emotional state of the user using an emotion engine and adjusting the explanation and display method of the generated rule based on the analysis results, and means for displaying the detected conflict information and the adjusted explanation of the rule to the user. This makes it possible to automatically and effectively generate new rules and explain conflicts with existing rules, and further to adjust the content of the explanation according to the emotional state of the user.

[0670] A "generative model" is an artificial intelligence technique that uses pre-trained algorithms to generate new rules and text.

[0671] "Organizational rules" refer to the rules and guidelines that employees and members must follow within an organization.

[0672] "Interface" refers to the means of providing a screen and input methods to enable interaction between a user and a system.

[0673] "Conflict detection" refers to the process of comparing new rules with existing rules to identify contradictions or inconsistencies.

[0674] An "emotion engine" refers to artificial intelligence technology for analyzing a user's emotional state, and has the ability to read emotions primarily from facial expressions and tone of voice.

[0675] "Emotional state" refers to a user's psychological response or emotional state at a particular moment.

[0676] "JSON format" stands for JavaScript Object Notation and refers to a text-based format for structuring and transferring data.

[0677] An "HTTP POST request" is one of the Internet protocols and refers to a request format for sending data to a server.

[0678] The present invention combines an emotion engine with a system that uses generative models to automatically generate and explain rules within an organization. The system provides an interface for users to input new rules, matches the new rules with existing rules to detect conflicts, and uses the emotion engine to recognize the user's emotional state and adjust the rule generation and explanation content accordingly.

[0679] Specific processing on the server side

[0680] 1. Load the generative model:

[0681] The server loads and initializes a pre-trained generative model (e.g., a general generative AI model), which is used to generate explanations for new rules, and deploys the model in the server's memory and makes it accessible through an API interface.

[0682] 2. Receipt of Request:

[0683] The server receives an HTTP POST request from the device. This request contains the new rules entered by the user in JSON format. For example, if the user enters "prohibit the use of smartphones during meetings," the server receives a request containing that rule.

[0684] 3. Explanation generation using generative models:

[0685] The server inputs the new rule into the generative model and generates a detailed explanation for the rule. The generative model generates an explanation by providing a prompt such as "New rule: XX. The reason is...". An explanation such as "Smartphone use is prohibited during meetings. This rule is intended to improve productivity" can be generated.

[0686] 4. Collision detection:

[0687] The server compares the new rule with existing rules to detect any inconsistencies or conflicts. For example, it analyzes the inconsistencies with an existing rule such as "Smartphones are allowed during meetings if there is an important message to be sent."

[0688] 5. Use of Emotion Engine:

[0689] The server uses an emotion engine (e.g., general emotion recognition software) to analyze the user's emotional data. Based on this data, it adjusts the rule explanation and display method. If the user shows resentment, it changes the wording to a softer one.

[0690] 6. Response Generation:

[0691] The server compiles the generated explanation, conflict information between the new rule and the existing rule, and information adjusted based on the emotional state as a JSON response, and sends this response to the device via HTTP POST.

[0692] Specific processing on the terminal side

[0693] 1. Providing the user interface:

[0694] The terminal provides an interface (e.g., a web page with text boxes and a submit button) for the user to enter new rules. Arrange the fields to make it easy for the user to enter them.

[0695] 2. Getting user input:

[0696] The terminal takes the rules entered by the user in the text box and converts them into JSON format, which includes metadata such as the rule content and timestamp.

[0697] 3. Acquiring emotional information:

[0698] The device uses cameras and other sensors to capture user emotion data, for example, by using facial recognition technology to analyze emotions from the user's facial expressions and add the data to a JSON format.

[0699] 4. View the response:

[0700] The device analyzes the response received from the server and displays the generated explanation, conflict information between the new rule and the existing rule, and content adjusted based on the user's emotional state. The information is displayed visually in a pop-up or modal window.

[0701] Specific examples

[0702] User operations

[0703] 1. The user enters "Prohibit smartphone use during meetings" into the device interface and clicks the send button.

[0704] 2. The device converts the rules entered by the user into JSON format and sends it to the server as an HTTP POST request along with the emotion data acquired by the facial recognition sensor.

[0705] Server Processing

[0706] 1. The server receives the request and extracts the new rule "prohibit smartphone use during meetings" and emotion data.

[0707] 2. The server inputs this rule into the generative model and generates the explanation, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[0708] 3. The server compares the new rule with existing rules and detects any inconsistencies with the existing rule, "Smartphones are allowed during meetings if there is an important message to be communicated."

[0709] 4. The server uses an emotion engine to analyze the user's emotional state, and if the user is showing resentment, adjusts the statement to a softer one, such as "The new rules are necessary to improve the efficiency of the entire organization."

[0710] 5. The server sends a JSON response to the device, including the generated description, collision points, and information adjusted based on emotion information.

[0711] Terminal handling

[0712] 1. The device receives the response from the server and analyzes it.

[0713] 2. The device displays the analysis results on the user interface and notifies users, for example, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule, 'Smartphone use is permitted during meetings if there is an important message to be communicated.' This rule has been established to improve efficiency across the organization."

[0714] The system allows users to receive detailed explanations of new rules and proactively identify conflicts with existing rules. Furthermore, the explanations are tailored to the user's emotional state, making it possible to present rules in a more acceptable format.

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

[0716] Step 1: Loading the Generative Model

[0717] The server loads pre-trained generative models and makes them accessible through an API interface. As input, it receives the file path and configuration information of the required model. The server loads this in memory and initializes it. As output, the generative model is ready to use.

[0718] Step 2: Receiving the request

[0719] The device provides an interface (e.g., a text box) where the user enters a new rule. The user initiates the request by entering "ban smartphones during meetings" and clicking the submit button. The server receives an HTTP POST request from the device. The input contains the new rule entered by the user in JSON format. The server parses the request and extracts the content of the new rule. The output is the text of the new rule.

[0720] Step 3: Generative model for generating explanations

[0721] The server inputs the new rule text into the generative model and generates a detailed explanation for that rule. The generative model generates an explanation by giving a prompt such as "New rule: XX. The reason is...". The text of the new rule is given as input, and the generated explanation is obtained as output.

[0722] Step 4: Collision detection

[0723] The server checks the new rule against existing rules to find inconsistencies and conflicts. Existing rules are loaded from a database. As input, the text of the new rule and the data of the existing rule are given. The server compares them and identifies conflicts. As output, it gets a list of conflicts.

[0724] Step 5: Use the Emotion Engine

[0725] The device uses a camera and other sensors to capture the user's emotional data and sends it to the server. The server then uses an emotion engine to analyze the user's emotional state. The user's emotional data is given as input, and the analysis results are obtained as output, which are used to adjust the explanation.

[0726] Step 6: Response Generation

[0727] The server compiles the generated description, conflict information between new rules and existing rules, and information adjusted based on the emotional state, and generates a response in JSON format. The input is the generated description, a list of conflict points, and the emotion analysis results. The server integrates these and generates response data as output, which is sent to the terminal as an HTTP response.

[0728] Step 7: View the response

[0729] The device parses the JSON response received from the server and displays information to the user in a visually understandable way. The response data received from the server is given as input. The device parses it and checks the generated explanation, conflict information between new rules and existing rules, and adjustments based on the emotional state. The output is the content displayed in the user interface.

[0730] (Application example 2)

[0731] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0732] Typically, creating and explaining rules within an organization is done manually, which requires a great deal of effort and time. Furthermore, when contradictions or conflicts arise between rules, the process of detecting and resolving them is complicated. Explaining and displaying rules in a way that is emotionally receptive to users is even more difficult. In particular, virtual stores are used by a diverse range of users, so individual, appropriate responses are required. The objective of this invention is to solve these problems and provide a system that automatically generates and explains rules and optimally displays them, taking into account the user's emotional state.

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

[0734] In this invention, the server includes: means for automatically generating and explaining rules within an organization using a generative model; means for providing an interface for a user to input a new rule; means for comparing the new rule with existing rules and detecting conflicts; means for displaying detected conflict information to the user; means for recognizing the user's emotional state using an emotion engine and adjusting the explanation and display content based on the emotional state; and means for adjusting prompt sentences based on the user's emotional state when generating a new rule explanation. This makes it possible to automatically and dynamically explain and display rules to a variety of users and provide optimal responses according to their emotions.

[0735] A "generative model" is an artificial intelligence technology that generates new information based on previously learned data.

[0736] "Organizational rules" refer to instructions and regulations set within a particular organization or group.

[0737] An "emotion engine" is a system that recognizes a user's emotional state by analyzing their facial expressions, voice, and other data.

[0738] An "interface" is the means or medium through which a user accesses and operates a system.

[0739] "Matching" is the act of comparing two or more pieces of data to see if they match.

[0740] Detecting a "conflict" means discovering whether a new rule that is generated contradicts an existing rule.

[0741] "Adjust" refers to changing or optimizing content for specific conditions or circumstances.

[0742] A "prompt sentence" is a basic sentence or instruction that serves as input to a generative model.

[0743] This invention is a system that automatically generates and explains rules within an organization using a generative model and an emotion engine. The system provides an interface for inputting new rules, generates detailed explanations using the generative model, detects conflicts with existing rules, and adjusts the explanations and display content based on the user's emotional state.

[0744] Server-side configuration

[0745] The server has the following main functions:

[0746] 1. Loading a Generative Model: The server loads and initializes a pre-trained generative model (e.g., OpenAI's API). This generative model receives a prompt to explain the new rule as input and generates a detailed explanation.

[0747] 2. Receiving a request: The server receives the HTTP POST request sent from the device and extracts the new rules and emotion data entered by the user.

[0748] 3. Explanation generation: The server inputs the new rule into the generative model and generates a detailed explanation based on the user's sentiment. For example, if a user inputs "Smartphone use is prohibited during meetings," the generative model generates the explanation "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[0749] 4. Conflict detection: The server loads the new rule and the existing rule from the database and compares them to detect any inconsistencies or conflicts. For example, if an existing rule states, "Smartphones are allowed during meetings if there are important communications," a conflict will be detected.

[0750] 5. Use of Emotion Engine: The server uses an emotion engine (e.g., EmotionEngine) to analyze the user's emotional state and adjust the generated explanation based on that information. For example, if the user expresses dislike, it adds the explanation, "In addition, this rule was established to reduce the burden on the user."

[0751] 6. Response generation: The server compiles the generated explanation, contradiction information, and adjustments based on emotion information into a JSON-formatted response and sends it to the device.

[0752] Terminal configuration

[0753] The terminal has the following main features:

[0754] 1. Providing an interface: The terminal provides an interface (e.g., a text box and a submit button) for the user to input new rules.

[0755] 2. Obtaining user input: The device obtains the rules entered by the user and analyzes the user's emotional state using sensors such as a camera.

[0756] 3. Data transmission: The device converts the new rules and emotion information into JSON format and sends it to the server as an HTTP POST request.

[0757] 4. Displaying the response: The terminal analyzes the response received from the server and displays the generated explanation, conflict information, and adjustments based on the emotion information to the user.

[0758] Specific example explanation

[0759] The user enters "Smartphone use is prohibited during meetings" into the device interface and clicks the send button. The device converts the rule into JSON format, obtains the user's emotional state, and sends them to the server as an HTTP POST request. The server receives the request and extracts the new rule "Smartphone use is prohibited during meetings" and emotional data. This rule is input into the generative model, and an explanation is generated: "Smartphone use is prohibited during meetings. This rule is intended to improve productivity." A contradiction with the existing rule "Smartphone use is permitted during meetings if there is an important message to be communicated." The emotion engine also analyzes the user's emotional state, and if it is determined to be "negative," a correction is made: "In addition, this rule has been established to reduce the user's burden." Finally, the generated explanation and contradictions are sent to the device in JSON format and displayed to the user.

[0760] Prompt Sentence Examples

[0761] Please generate detailed explanations for the following rules:

[0762] ---

[0763] Rule: "No smartphones allowed during meetings."

[0764] ---

[0765] Detailed Description:

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

[0767] Step 1:

[0768] Getting User Input

[0769] The user inputs a new rule into the device interface and clicks the submit button. The input rule is "prohibit the use of smartphones during meetings." At the same time, the device's camera captures the user's emotional data. The input data and emotional data are obtained.

[0770] Step 2:

[0771] Data transmission

[0772] The device converts the acquired new rules and emotion data into JSON format and sends it to the server as an HTTP POST request. The request content includes the new rules and emotion data. The input data is the new rules and emotion data, and the output data is the HTTP request.

[0773] Step 3:

[0774] Receipt of request

[0775] The server receives the HTTP POST request, analyzes the content, extracts new rules and emotion data, and stores them in the respective variables. The input data is the HTTP request, and the output data is the new rules and emotion data.

[0776] Step 4:

[0777] Using generative models

[0778] The server inputs a prompt and a new rule into a pre-loaded generative model (e.g., OpenAI's API). Prompt: "The use of smartphones is prohibited during meetings." The generative model generates a detailed explanation based on this prompt. The explanation is "The use of smartphones is prohibited during meetings. This rule is intended to improve productivity." The input data is the prompt and the new rule, and the output data is the explanation.

[0779] Step 5:

[0780] Collision Detection

[0781] The server loads existing rules from the database and compares them with the new rule. For example, if an existing rule states, "Smartphones are allowed during meetings if there is an important message," the server detects the inconsistency. The input data is the new rule and the existing rule, and the output data is the inconsistency information.

[0782] Step 6:

[0783] Using the Emotion Engine

[0784] The server uses an emotion engine (e.g., EmotionEngine) to analyze the user's emotion data. If the emotion is recognized as "negative," it adds a note to the generated explanation saying, "This rule was established to reduce the burden on the user." The input data is the emotion data, and the output data is the corrected explanation.

[0785] Step 7:

[0786] Response Generation

[0787] The server generates a final response based on the generated description, contradiction information, and emotion information. The response is sent to the terminal in JSON format. The input data are the generated description, contradiction information, and emotion information, and the output data is the JSON format response.

[0788] Step 8:

[0789] Viewing the response

[0790] The terminal parses the JSON response received from the server and displays it to the user. The user can then check the generated explanation for any discrepancies between the explanation and existing rules, as well as supplementary explanations based on emotions. The input data is the JSON response, and the output data is displayed on the user interface.

[0791] The specific processing unit 290 transmits the result of the specific processing to the smart glasses 214. In the smart glasses 214, the control unit 46A causes the speaker 240 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

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

[0793] In the above embodiment, an example in which the specific processing is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the smart glasses 214.

[0794] [Third embodiment]

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

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

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

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

[0799] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

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

[0801] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0802] Fig. 6 shows an example of the main functions of the data processing device 12 and the headset type terminal 314. As shown in Fig. 6, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0803] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

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

[0805] In the headset type terminal 314, a reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0806] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the headset type terminal 314 will be referred to as the "terminal."

[0807] The present invention relates to a system that automatically generates and explains rules within an organization using a generative model. This system has an interface for users to input new rules, compares the new rules with existing rules, detects conflicts, and displays them to the user. Specific embodiments for implementing the present invention are described below.

[0808] System configuration

[0809] Server side

[0810] The server has the following main functions:

[0811] 1. Load Generative Model: The server loads and initializes a pre-trained generative model, which is used to generate explanations for new rules.

[0812] 2. Receiving a request: The server receives an HTTP POST request sent from the terminal, which includes the new rules entered by the user.

[0813] 3. Explanation generation using the generative model: The server inputs a new rule into the generative model and generates a detailed explanation for that rule.

[0814] 4. Conflict Detection: The server detects possible inconsistencies or conflicts between new rules and existing rules.

[0815] 5. Response generation: The server compiles the generated explanation and detected conflict information and sends it to the terminal as a JSON-formatted response.

[0816] Terminal side

[0817] The terminal has the following main features:

[0818] 1. Providing a user interface: The terminal provides an interface for the user to enter new rules, including a text box and a submit button.

[0819] 2. Obtaining user input: The terminal obtains the rules entered by the user and generates a request to send to the server.

[0820] 3. Displaying the response: The terminal analyzes the response received from the server and displays the generated explanation and conflict information to the user.

[0821] Specific examples

[0822] User operations

[0823] 1. The user enters "Prohibit use of smartphones during meetings" into the device's user interface and clicks the send button.

[0824] 2. The device converts the rules into JSON format and sends it to the server as an HTTP POST request.

[0825] Server Processing

[0826] 1. The server receives the request and extracts a new rule: "Do not use smartphones during meetings."

[0827] 2. The server inputs this rule into the generative model and generates an explanation: "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[0828] 3. The server compares the new rule with existing rules and detects any conflicts with the existing rule, "Smartphone use is permitted during meetings if there is an important message to be communicated."

[0829] 4. The server generates a JSON response containing the generated explanation and discrepancies and sends it to the device.

[0830] Terminal handling

[0831] 1. The terminal receives the response from the server and analyzes it.

[0832] 2. The device displays the analysis results to the user and notifies them, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule: Smartphone use is permitted during meetings if there is an important message to be communicated."

[0833] This system allows users to effectively receive explanations of new rules and proactively identify conflicts with existing rules, resulting in fast and efficient rule dissemination throughout the organization.

[0834] The processing flow will be explained below.

[0835] Step 1:

[0836] The user enters a new rule into the device's user interface, for example, "Do not use smartphones during meetings."

[0837] Step 2:

[0838] The user clicks the "Send" button.

[0839] Step 3:

[0840] The terminal takes the rules entered by the user and converts them into JSON format.

[0841] Step 4:

[0842] The terminal sends the converted JSON data to the server as an HTTP POST request.

[0843] Step 5:

[0844] The server receives the request sent from the terminal.

[0845] Step 6:

[0846] The server extracts the new rules from the body of the request.

[0847] Step 7:

[0848] The server inputs the extracted new rules into the generative model and generates a detailed description of the rules.

[0849] Step 8:

[0850] The server checks the new rules against existing rules to detect any inconsistencies or conflicts.

[0851] Step 9:

[0852] The server compiles the generated description and any detected conflicts into a JSON-formatted response.

[0853] Step 10:

[0854] The server sends the generated JSON response to the terminal.

[0855] Step 11:

[0856] The terminal receives the response from the server.

[0857] Step 12:

[0858] The device parses the received JSON response and extracts the generated description and collision information.

[0859] Step 13:

[0860] The terminal displays the extracted explanatory text and conflict information on a user interface.

[0861] Step 14:

[0862] The user checks the displayed content and understands the new rules, their explanations, and conflict information.

[0863] Example 1

[0864] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0865] When managing rules within an organization, there is a need to quickly detect inconsistencies and conflicts with existing rules when introducing new rules and to notify users in an easy-to-understand manner. However, when creating rules and detecting conflicts manually, there is a problem that efficient management is difficult due to the large amount of manual work required. Furthermore, automatically generating explanations for complex rules requires advanced technology, which is difficult to achieve.

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

[0867] In this invention, the server includes means for automatically generating and explaining rules within an organization using a generative model, means for receiving an HTTP POST request and inputting a new rule into the generative model, means for generating an explanation of the new rule using the generative model, means for matching the new rule with existing rules and retrieving information from a database, means for detecting conflicts between the new rule and existing rules, and means for sending the generated explanation and detected conflict information to a terminal as a JSON-formatted response. This makes it possible to automatically detect inconsistencies and conflicts with existing rules when a user introduces a new rule and notify the user quickly and clearly.

[0868] A "generative model" refers to an artificial intelligence algorithm that generates new sentences and explanations based on text data entered by a user.

[0869] "Interface" refers to a screen or device that allows a user to input information into a system.

[0870] An "HTTP POST request" is a type of protocol for sending data to a server when a user inputs a new rule.

[0871] "Database" refers to a system for storing existing rules and for searching and matching them.

[0872] "JSON format" is a format for structuring and expressing data in text format, and is an abbreviation for JavaScript Object Notation.

[0873] "Terminal" refers to an electronic device through which a user accesses and operates the system.

[0874] "Conflict detection" refers to the process of checking for conflicts or inconsistencies between new rules and existing rules.

[0875] "Response" refers to response data sent from the server to the terminal.

[0876] "Parsing" refers to the process of interpreting data received from the server and converting it into an understandable format.

[0877] This invention relates to a system that uses generative AI models to automatically generate and explain rules within an organization. The system has an interface for users to input new rules, matches the new rules with existing rules, detects conflicts, and displays them to the user.

[0878] Server-side configuration

[0879] The server has the following main functions:

[0880] 1. Load the generative model:

[0881] At system startup, the server loads a pre-trained generative AI model, such as a natural language processing model like GPT-3 or BERT, which is used to generate detailed descriptions of new rules.

[0882] 2. Receipt of Request:

[0883] The server receives an HTTP POST request from the device. The request contains the new rules entered by the user in JSON format. For example, if the user enters "prohibit the use of smartphones during meetings," the server proceeds with processing based on this information.

[0884] 3. Explanation generation using generative models:

[0885] The server inputs the new rules it has acquired into a generative AI model, which then generates a detailed explanation based on the rules. For example, if the prompt "Smartphone use is prohibited during meetings" is input into the generative model, the generated explanation will be "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[0886] 4. Collision detection:

[0887] The server checks the new rule against the existing rules, which are loaded from a database, to detect any conflicts. For example, if an existing rule states, "Smartphones are allowed during meetings if there are important communications," the server detects a conflict between the new and old rules.

[0888] 5. Response generation and transmission:

[0889] The server sends the generated description and detected collision information to the device as a JSON-formatted response.

[0890] Terminal configuration

[0891] The terminal has the following main features:

[0892] 1. Providing the user interface:

[0893] The terminal provides an interface for the user to enter new rules, which includes a text box and a submit button. The user enters the new rule through this interface and clicks the submit button.

[0894] 2. Getting user input and generating a request:

[0895] It takes the rules entered by the user, converts them into JSON format, and sends them to the server as an HTTP POST request. For example, if a user enters "prohibit the use of smartphones during meetings," this rule will be sent to the server.

[0896] 3. Receiving and Parsing Responses:

[0897] Receives the response from the server and parses it, extracting the generated description and collision information from the received JSON data.

[0898] 4. View the response:

[0899] The analysis results are displayed to the user. The user can visually see the explanation of the new rule and any conflicts with existing rules. For example, the display might say, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule 'Smartphone use is permitted during meetings if there is an important message.'"

[0900] This system allows users to effectively receive explanations of new rules and identify conflicts with existing rules in advance, which is expected to result in quick and efficient dissemination of rules throughout the organization.

[0901] Prompt Sentence Examples

[0902] "Check the new rule against existing rules and detect conflicts. New rule: 'No smartphones allowed during meetings.'"

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

[0904] Step 1: Loading the Generative Model

[0905] At system startup, the server loads a pre-trained generative AI model, such as a natural language processing model like GPT-3 or BERT. This model is needed to generate explanations for new rules. The input is the model file, and the output is the initialized generative model.

[0906] Step 2: Providing a User Interface

[0907] The terminal provides an interface for the user to enter new rules. This interface includes a text box and a submit button. As the user enters rules, new rules are generated. The input is the user's actions, and the output is the rules entered by the user.

[0908] Step 3: Getting User Input and Creating a Request

[0909] The terminal takes the new rule entered by the user in the text box, converts it to JSON format, and generates an HTTP POST request that is sent to the server, with the input being the user's input data and the output being the JSON formatted request.

[0910] Step 4: Receiving the request

[0911] The server receives an HTTP POST request sent from the device, which contains the new rules entered by the user. The input is the JSON formatted request, and the output is the parsed new rule data.

[0912] Step 5: Generative model for generating explanations

[0913] The server inputs the new rule into the generative model, which then generates a detailed explanation based on the rule. Specifically, the new rule, "No smartphones allowed during meetings," is used as the prompt to generate the explanation, "No smartphones allowed during meetings. This rule is intended to improve productivity." The input is the new rule, and the output is the generated explanation.

[0914] Step 6: Collision detection

[0915] The server loads existing rules from the database to compare the new rule with the existing rules. It checks the new rule against the existing rules to detect inconsistencies and collisions. For example, if the new rule is "Smartphones are prohibited during meetings" and the existing rule is "Smartphones are allowed during meetings if there is an important message," it detects a conflict. The input is the new rule and the existing rule data, and the output is the detected conflict information.

[0916] Step 7: Generate and send a response

[0917] The server compiles the generated explanation and the detected inconsistencies and generates a JSON-formatted response, which is sent to the device. The input is the generated explanation and the detected inconsistencies, and the output is a JSON-formatted response.

[0918] Step 8: Receiving and Parsing the Response

[0919] The terminal receives the response sent from the server and parses it. It extracts the explanation and contradiction information generated from the parsed data. The input is a JSON-formatted response, and the output is the parsed explanation and contradiction information.

[0920] Step 9: View the response

[0921] The device displays the analysis results to the user. The user can see the explanation of the new rule and any conflicts with existing rules. For example, the user receives a notification that reads, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule 'Smartphone use is permitted during meetings if there is an important message.'" The input is the analyzed data, and the output is what is displayed to the user.

[0922] (Application example 1)

[0923] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0924] When introducing new operational and safety rules in existing factories, there is a high possibility that they will conflict with existing rules. This poses a risk of compromising safety and efficiency. Additionally, the process of explaining the new rules and verifying their validity is time-consuming, making it difficult to respond quickly.

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

[0926] In this invention, the server includes means for explaining a new rule using a generative model and detecting inconsistencies therein, means for providing an interface for a user to input the new rule, and means for comparing the new rule with existing rules and detecting conflicts, thereby enabling the user to quickly receive an explanation of the new rule and immediately grasp any inconsistencies with existing rules.

[0927] A "generative model" is an algorithm that uses machine learning or deep learning to learn patterns in documents and data and generate new data and documents.

[0928] A "user" is a person or group that interacts with the system by inputting new rules and constraints.

[0929] An "interface" is the screen or part of the application that the user uses to enter new rules and that is responsible for sending the data to the server.

[0930] "Rules" are the regulations and guidelines that apply within an organization or system.

[0931] "Verification" is the process of comparing new rules with existing rules to identify differences or inconsistencies.

[0932] "Conflict" refers to a situation in which two or more rules contradict each other and are difficult to apply simultaneously.

[0933] "Conflict Information" means data or notifications that indicate conflicts that arise between new rules and existing rules.

[0934] "JSON format" is a lightweight data exchange format for expressing data in text format, and is an abbreviation for JavaScript Object Notation.

[0935] The "server" is the central processing unit that runs the generative model, generates new rule explanations, and detects inconsistencies.

[0936] A "smartphone application" is software that runs on a smartphone and is a program that has functions such as user input, communication with a server, and display of results.

[0937] This invention relates to a system that uses generative models to automatically generate and explain operational and safety rules in factories and detect conflicts with existing rules. This system consists of a smartphone application that allows users to input new rules and check the results, and a server that generates rules and detects conflicts.

[0938] Server configuration and operation

[0939] 1. Load the generative model:

[0940] The server loads and initializes a pre-trained generative model (e.g., GPT-2), which is then used to generate explanations for new rules.

[0941] 2. Receipt of Request:

[0942] The server receives an HTTP POST request sent from the user's device, which contains the new rules entered by the user.

[0943] 3. Explanation generation using generative models:

[0944] The server inputs new rules into the generative model and generates a detailed description of the rules.

[0945] 4. Collision detection:

[0946] The server checks the new rules against existing rules to detect inconsistencies and conflicts, and loads existing rules from a database to perform conflict detection based on the necessary information.

[0947] 5. Response Generation:

[0948] The server compiles the generated explanation and the detected discrepancies and sends it to the device as a JSON-formatted response.

[0949] Terminal configuration and operation

[0950] 1. Providing the user interface:

[0951] The terminal provides an interface for the user to enter new rules, which includes a text box and a submit button.

[0952] 2. Getting user input:

[0953] After the user enters a new rule, the terminal converts the rule into JSON format and sends it to the server as an HTTP POST request.

[0954] 3. View the response:

[0955] The terminal analyzes the response received from the server and displays the generated explanation and contradiction information to the user. As a concrete example, the following input and output are possible:

[0956] Specific examples

[0957] User operations

[0958] The user inputs "The speed of forklifts will be limited in designated areas. The purpose is to prevent accidents" into the user interface of the terminal and clicks the send button.

[0959] Server Processing

[0960] The server receives the request and extracts a new rule: "Limit the speed of forklifts in designated areas. The purpose is to prevent accidents."

[0961] The server inputs this rule into the generative model and generates the explanation, "Forklift speeds are limited in designated areas. This is to prevent accidents."

[0962] The server compares the new rule with existing rules and detects any inconsistencies with the existing rule that "high priority transports are performed at high speed."

[0963] The server generates a JSON response containing the generated explanation and discrepancies and sends it to the device.

[0964] Terminal handling

[0965] The terminal receives the response from the server and analyzes it.

[0966] The terminal displays the analysis results to the user, informing them, "New rule: Limit forklift speeds in designated areas. This is intended to prevent accidents. However, it may conflict with the existing rule: 'High-priority transport must be done at high speeds.'"

[0967] Prompt Sentence Examples

[0968] Example user input:

[0969] "The speed of forklifts is limited in designated areas. The purpose is to prevent accidents."

[0970] The present invention allows new rules to be smoothly introduced within the factory, and makes it possible to maintain safety and efficiency.

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

[0972] Step 1:

[0973] The terminal provides an interface for the user to input new rules. The user enters the new rule in a text box on the interface and clicks the submit button. An example of user input is "Limit the speed of forklifts in designated areas. The purpose is to prevent accidents."

[0974] Step 2:

[0975] The terminal receives the rules entered by the user and converts them into JSON format. The converted data is sent to the server as an HTTP POST request. If the new rule entered is "Limit the speed of forklifts in designated areas. The purpose is to prevent accidents," it is sent to the server as JSON data.

[0976] Step 3:

[0977] The server receives an HTTP POST request and parses the JSON data in the request. It extracts new rules from the parsed data. The server inputs the new rules into the generative model, which then generates an explanation for the rules. For example, the generative model might generate an explanation like, "Forklift speeds are limited in designated areas. This is to prevent accidents."

[0978] Step 4:

[0979] The server loads existing rules from the database to match the new rule with the existing rules. The server compares the new rule with the existing rules to detect inconsistencies and conflicts. For example, if the new rule "Limit the speed of forklifts in designated areas" conflicts with the existing rule "High-priority transport must be done at high speeds," it generates inconsistency information.

[0980] Step 5:

[0981] The server generates a response in JSON format that includes the description of the generated rule and any conflicts. For example, the generated JSON response might read, "Description: Limits the speed of forklifts in the specified area. This is to prevent accidents. Conflicting existing rule: High-priority transport must be done at high speeds."

[0982] Step 6:

[0983] The terminal parses the JSON response received from the server and displays the generated explanation and conflict information to the user. Specifically, it notifies the user that "New rule: Limit the speed of forklifts in designated areas. This is intended to prevent accidents. However, this may conflict with the existing rule 'High-priority transport should be done at high speeds.'"

[0984] By following these steps, the user can accurately input a new rule and quickly understand the rule's description and any inconsistencies with existing rules.

[0985] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0986] This invention combines an emotion engine with a system that uses generative models to automatically generate and explain rules within an organization. The system has an interface for users to input new rules, matches the new rules with existing rules, detects conflicts, and uses the emotion engine to recognize the user's emotional state and adjust the rule generation and explanation content based on that.

[0987] System configuration

[0988] Server side

[0989] The server has the following main functions:

[0990] 1. Loading the Generative Model: The server loads and initializes a pre-trained generative model, which is used to generate explanations for new rules.

[0991] 2. Receiving the request: The server receives the HTTP POST request sent from the terminal and extracts the new rules entered by the user.

[0992] 3. Explanation generation using the generative model: The server inputs the new rule into the generative model and generates a detailed explanation for the rule.

[0993] 4. Conflict detection: The server checks the new rules against existing rules to detect inconsistencies or conflicts.

[0994] 5. Use of Emotion Engine: The server uses the emotion engine to analyze the user's emotional state and adjusts the explanation and display of the rule based on that information.

[0995] 6. Response generation: The server compiles the generated explanation, conflict information, and adjustments based on emotion information into a JSON-formatted response and sends it to the device.

[0996] Terminal side

[0997] The terminal has the following main features:

[0998] 1. Providing a user interface: The terminal provides an interface for the user to enter new rules, including a text box and a submit button.

[0999] 2. Obtaining user input: The terminal obtains the rules entered by the user and generates a request to send to the server.

[1000] 3. Acquiring emotional information: The device acquires the user's emotions using sensors such as a camera and sends them to the server.

[1001] 4. Displaying the response: The terminal analyzes the response received from the server and displays the generated explanation, conflict information, and adjustments based on the emotion information to the user.

[1002] Specific examples

[1003] User operations

[1004] 1. The user enters "Prohibit use of smartphones during meetings" into the device's user interface and clicks the send button.

[1005] 2. The device converts the rules into JSON format, obtains the user's emotional state, and sends them to the server as an HTTP POST request.

[1006] Server Processing

[1007] 1. The server receives the request and extracts the new rule "prohibit smartphone use during meetings" and emotion data.

[1008] 2. The server inputs this rule into the generative model and generates an explanation: "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[1009] 3. The server compares the new rule with existing rules and detects any conflicts with the existing rule, "Smartphone use is permitted during meetings if there is an important message to be communicated."

[1010] 4. The server uses an emotion engine to analyze the user's emotional state and adjust the content and presentation of the explanation accordingly. For example, if the user is expressing disapproval, the explanation will be softened.

[1011] 5. The server sends a JSON response to the device containing the generated explanation, discrepancies, and information adjusted based on the emotion information.

[1012] Terminal handling

[1013] 1. The device receives the response from the server and analyzes it.

[1014] 2. The device displays the analysis results on the user interface and notifies the user, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule, 'Smartphone use is permitted during meetings if there is important communication to be made.' This rule has been established to improve efficiency across the organization."

[1015] This system allows users to effectively receive explanations of new rules and proactively identify conflicts with existing rules. Furthermore, the system dynamically adjusts the explanation and presentation of rules according to the user's emotional state, making it possible to communicate rules in a more acceptable manner.

[1016] The processing flow will be explained below.

[1017] Step 1:

[1018] The user enters a new rule into the device's user interface, for example, "Do not use smartphones during meetings."

[1019] Step 2:

[1020] The user provides their emotional state (e.g., facial expression or tone of voice) through sensors such as a camera or microphone on the device, which the device then captures as emotion data.

[1021] Step 3:

[1022] The user clicks the "Send" button.

[1023] Step 4:

[1024] The device receives the rules entered by the user and converts them into JSON format, as well as the emotion data.

[1025] Step 5:

[1026] The device sends an HTTP POST request containing the converted rules and emotion data to the server.

[1027] Step 6:

[1028] The server receives the request sent from the terminal.

[1029] Step 7:

[1030] The server extracts the new rules and emotion data from the body of the request.

[1031] Step 8:

[1032] The server inputs the extracted new rule into the generative model and generates a detailed explanation of the rule, for example, "The use of smartphones during meetings is prohibited. This rule is intended to improve productivity."

[1033] Step 9:

[1034] The server checks the new rule against existing rules to detect any inconsistencies or conflicts, such as a conflict with an existing rule that says, "Smartphones are allowed during meetings if there is an important message to be sent."

[1035] Step 10:

[1036] The server uses an emotion engine to analyze the user's emotional state, for example, the emotion engine determines that the user is expressing dislike.

[1037] Step 11:

[1038] The server adjusts the explanation and presentation of the rule based on the results of the emotion engine's analysis. For example, if the user expresses dislike, the explanation will be presented in a gentler way.

[1039] Step 12:

[1040] The server generates a JSON response containing the adjusted description, detected collision information, and emotion information.

[1041] Step 13:

[1042] The server sends the generated JSON response to the device.

[1043] Step 14:

[1044] The terminal receives the response from the server.

[1045] Step 15:

[1046] The device analyzes the received JSON response and extracts adjustments based on the generated description, conflict information, and emotion information.

[1047] Step 16:

[1048] The device displays the extracted explanation, conflict information, and adjustment details on the user interface. For example, it might say, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule, 'Smartphone use is permitted during meetings if there is an important message to be communicated.' This rule was established to improve efficiency across the organization."

[1049] Step 17:

[1050] The user checks the displayed content and understands the new rules and their explanations, as well as the collision information and their adjustments.

[1051] Example 2

[1052] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1053] When formulating new rules within an organization, it was difficult to detect conflicts with existing rules in advance and clearly explain the conflicts. Furthermore, it was not possible to appropriately adjust the explanation based on the user's emotional state, which could lead to user resistance and confusion.

[1054] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for automatically generating and explaining rules within an organization using a generative model, means for providing an interface for a user to input a new rule, means for matching the new rule with existing rules and detecting conflicts, means for analyzing the emotional state of the user using an emotion engine and adjusting the explanation and display method of the generated rule based on the analysis results, and means for displaying the detected conflict information and the adjusted explanation of the rule to the user. This makes it possible to automatically and effectively generate new rules and explain conflicts with existing rules, and further to adjust the content of the explanation according to the emotional state of the user.

[1055] A "generative model" is an artificial intelligence technique that uses pre-trained algorithms to generate new rules and text.

[1056] "Organizational rules" refer to the rules and guidelines that employees and members must follow within an organization.

[1057] "Interface" refers to the means of providing a screen and input methods to enable interaction between a user and a system.

[1058] "Conflict detection" refers to the process of comparing new rules with existing rules to identify contradictions or inconsistencies.

[1059] An "emotion engine" refers to artificial intelligence technology for analyzing a user's emotional state, and has the ability to read emotions primarily from facial expressions and tone of voice.

[1060] "Emotional state" refers to a user's psychological response or emotional state at a particular moment.

[1061] "JSON format" stands for JavaScript Object Notation and refers to a text-based format for structuring and transferring data.

[1062] An "HTTP POST request" is one of the Internet protocols and refers to a request format for sending data to a server.

[1063] The present invention combines an emotion engine with a system that uses generative models to automatically generate and explain rules within an organization. The system provides an interface for users to input new rules, matches the new rules with existing rules to detect conflicts, and uses the emotion engine to recognize the user's emotional state and adjust the rule generation and explanation content accordingly.

[1064] Specific processing on the server side

[1065] 1. Load the generative model:

[1066] The server loads and initializes a pre-trained generative model (e.g., a general generative AI model), which is used to generate explanations for new rules, and deploys the model in the server's memory and makes it accessible through an API interface.

[1067] 2. Receipt of Request:

[1068] The server receives an HTTP POST request from the device. This request contains the new rules entered by the user in JSON format. For example, if the user enters "prohibit the use of smartphones during meetings," the server receives a request containing that rule.

[1069] 3. Explanation generation using generative models:

[1070] The server inputs the new rule into the generative model and generates a detailed explanation for the rule. The generative model generates an explanation by providing a prompt such as "New rule: XX. The reason is...". An explanation such as "Smartphone use is prohibited during meetings. This rule is intended to improve productivity" can be generated.

[1071] 4. Collision detection:

[1072] The server compares the new rule with existing rules to detect any inconsistencies or conflicts. For example, it analyzes the inconsistencies with an existing rule such as "Smartphones are allowed during meetings if there is an important message to be sent."

[1073] 5. Use of Emotion Engine:

[1074] The server uses an emotion engine (e.g., general emotion recognition software) to analyze the user's emotional data. Based on this data, it adjusts the rule explanation and display method. If the user shows resentment, it changes the wording to a softer one.

[1075] 6. Response Generation:

[1076] The server compiles the generated explanation, conflict information between the new rule and the existing rule, and information adjusted based on the emotional state as a JSON response, and sends this response to the device via HTTP POST.

[1077] Specific processing on the terminal side

[1078] 1. Providing the user interface:

[1079] The terminal provides an interface (e.g., a web page with text boxes and a submit button) for the user to enter new rules. Arrange the fields to make it easy for the user to enter them.

[1080] 2. Getting user input:

[1081] The terminal takes the rules entered by the user in the text box and converts them into JSON format, which includes metadata such as the rule content and timestamp.

[1082] 3. Acquiring emotional information:

[1083] The device uses cameras and other sensors to capture user emotion data, for example, by using facial recognition technology to analyze emotions from the user's facial expressions and add the data to a JSON format.

[1084] 4. View the response:

[1085] The device analyzes the response received from the server and displays the generated explanation, conflict information between the new rule and the existing rule, and content adjusted based on the user's emotional state. The information is displayed visually in a pop-up or modal window.

[1086] Specific examples

[1087] User operations

[1088] 1. The user enters "Prohibit smartphone use during meetings" into the device interface and clicks the send button.

[1089] 2. The device converts the rules entered by the user into JSON format and sends it to the server as an HTTP POST request along with the emotion data acquired by the facial recognition sensor.

[1090] Server Processing

[1091] 1. The server receives the request and extracts the new rule "prohibit smartphone use during meetings" and emotion data.

[1092] 2. The server inputs this rule into the generative model and generates the explanation, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[1093] 3. The server compares the new rule with existing rules and detects any inconsistencies with the existing rule, "Smartphones are allowed during meetings if there is an important message to be communicated."

[1094] 4. The server uses an emotion engine to analyze the user's emotional state, and if the user is showing resentment, adjusts the statement to a softer one, such as "The new rules are necessary to improve the efficiency of the entire organization."

[1095] 5. The server sends a JSON response to the device, including the generated description, collision points, and information adjusted based on emotion information.

[1096] Terminal handling

[1097] 1. The device receives the response from the server and analyzes it.

[1098] 2. The device displays the analysis results on the user interface and notifies users, for example, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule, 'Smartphone use is permitted during meetings if there is an important message to be communicated.' This rule has been established to improve efficiency across the organization."

[1099] The system allows users to receive detailed explanations of new rules and proactively identify conflicts with existing rules. Furthermore, the explanations are tailored to the user's emotional state, making it possible to present rules in a more acceptable format.

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

[1101] Step 1: Loading the Generative Model

[1102] The server loads pre-trained generative models and makes them accessible through an API interface. As input, it receives the file path and configuration information of the required model. The server loads this in memory and initializes it. As output, the generative model is ready to use.

[1103] Step 2: Receiving the request

[1104] The device provides an interface (e.g., a text box) where the user enters a new rule. The user initiates the request by entering "ban smartphones during meetings" and clicking the submit button. The server receives an HTTP POST request from the device. The input contains the new rule entered by the user in JSON format. The server parses the request and extracts the content of the new rule. The output is the text of the new rule.

[1105] Step 3: Generative model for generating explanations

[1106] The server inputs the new rule text into the generative model and generates a detailed explanation for that rule. The generative model generates an explanation by giving a prompt such as "New rule: XX. The reason is...". The text of the new rule is given as input, and the generated explanation is obtained as output.

[1107] Step 4: Collision detection

[1108] The server checks the new rule against existing rules to find inconsistencies and conflicts. Existing rules are loaded from a database. As input, the text of the new rule and the data of the existing rule are given. The server compares them and identifies conflicts. As output, it gets a list of conflicts.

[1109] Step 5: Use the Emotion Engine

[1110] The device uses a camera and other sensors to capture the user's emotional data and sends it to the server. The server then uses an emotion engine to analyze the user's emotional state. The user's emotional data is given as input, and the analysis results are obtained as output, which are used to adjust the explanation.

[1111] Step 6: Response Generation

[1112] The server compiles the generated description, conflict information between new rules and existing rules, and information adjusted based on the emotional state, and generates a response in JSON format. The input is the generated description, a list of conflict points, and the emotion analysis results. The server integrates these and generates response data as output, which is sent to the terminal as an HTTP response.

[1113] Step 7: View the response

[1114] The device parses the JSON response received from the server and displays information to the user in a visually understandable way. The response data received from the server is given as input. The device parses it and checks the generated explanation, conflict information between new rules and existing rules, and adjustments based on the emotional state. The output is the content displayed in the user interface.

[1115] (Application example 2)

[1116] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1117] Typically, creating and explaining rules within an organization is done manually, which requires a great deal of effort and time. Furthermore, when contradictions or conflicts arise between rules, the process of detecting and resolving them is complicated. Explaining and displaying rules in a way that is emotionally receptive to users is even more difficult. In particular, virtual stores are used by a diverse range of users, so individual, appropriate responses are required. The objective of this invention is to solve these problems and provide a system that automatically generates and explains rules and optimally displays them, taking into account the user's emotional state.

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

[1119] In this invention, the server includes: means for automatically generating and explaining rules within an organization using a generative model; means for providing an interface for a user to input a new rule; means for comparing the new rule with existing rules and detecting conflicts; means for displaying detected conflict information to the user; means for recognizing the user's emotional state using an emotion engine and adjusting the explanation and display content based on the emotional state; and means for adjusting prompt sentences based on the user's emotional state when generating a new rule explanation. This makes it possible to automatically and dynamically explain and display rules to a variety of users and provide optimal responses according to their emotions.

[1120] A "generative model" is an artificial intelligence technology that generates new information based on previously learned data.

[1121] "Organizational rules" refer to instructions and regulations set within a particular organization or group.

[1122] An "emotion engine" is a system that recognizes a user's emotional state by analyzing their facial expressions, voice, and other data.

[1123] An "interface" is the means or medium through which a user accesses and operates a system.

[1124] "Matching" is the act of comparing two or more pieces of data to see if they match.

[1125] Detecting a "conflict" means discovering whether a new rule that is generated contradicts an existing rule.

[1126] "Adjust" refers to changing or optimizing content for specific conditions or circumstances.

[1127] A "prompt sentence" is a basic sentence or instruction that serves as input to a generative model.

[1128] This invention is a system that automatically generates and explains rules within an organization using a generative model and an emotion engine. The system provides an interface for inputting new rules, generates detailed explanations using the generative model, detects conflicts with existing rules, and adjusts the explanations and display content based on the user's emotional state.

[1129] Server-side configuration

[1130] The server has the following main functions:

[1131] 1. Loading a Generative Model: The server loads and initializes a pre-trained generative model (e.g., OpenAI's API). This generative model receives a prompt to explain the new rule as input and generates a detailed explanation.

[1132] 2. Receiving a request: The server receives the HTTP POST request sent from the device and extracts the new rules and emotion data entered by the user.

[1133] 3. Explanation generation: The server inputs the new rule into the generative model and generates a detailed explanation based on the user's sentiment. For example, if a user inputs "Smartphone use is prohibited during meetings," the generative model generates the explanation "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[1134] 4. Conflict detection: The server loads the new rule and the existing rule from the database and compares them to detect any inconsistencies or conflicts. For example, if an existing rule states, "Smartphones are allowed during meetings if there are important communications," a conflict will be detected.

[1135] 5. Use of Emotion Engine: The server uses an emotion engine (e.g., EmotionEngine) to analyze the user's emotional state and adjust the generated explanation based on that information. For example, if the user expresses dislike, it adds the explanation, "In addition, this rule was established to reduce the burden on the user."

[1136] 6. Response generation: The server compiles the generated explanation, contradiction information, and adjustments based on emotion information into a JSON-formatted response and sends it to the device.

[1137] Terminal configuration

[1138] The terminal has the following main features:

[1139] 1. Providing an interface: The terminal provides an interface (e.g., a text box and a submit button) for the user to input new rules.

[1140] 2. Obtaining user input: The device obtains the rules entered by the user and analyzes the user's emotional state using sensors such as a camera.

[1141] 3. Data transmission: The device converts the new rules and emotion information into JSON format and sends it to the server as an HTTP POST request.

[1142] 4. Displaying the response: The terminal analyzes the response received from the server and displays the generated explanation, conflict information, and adjustments based on the emotion information to the user.

[1143] Specific example explanation

[1144] The user enters "Smartphone use is prohibited during meetings" into the device interface and clicks the send button. The device converts the rule into JSON format, obtains the user's emotional state, and sends them to the server as an HTTP POST request. The server receives the request and extracts the new rule "Smartphone use is prohibited during meetings" and emotional data. This rule is input into the generative model, and an explanation is generated: "Smartphone use is prohibited during meetings. This rule is intended to improve productivity." A contradiction with the existing rule "Smartphone use is permitted during meetings if there is an important message to be communicated." The emotion engine also analyzes the user's emotional state, and if it is determined to be "negative," a correction is made: "In addition, this rule has been established to reduce the user's burden." Finally, the generated explanation and contradictions are sent to the device in JSON format and displayed to the user.

[1145] Prompt Sentence Examples

[1146] Please generate detailed explanations for the following rules:

[1147] ---

[1148] Rule: "No smartphones allowed during meetings."

[1149] ---

[1150] Detailed Description:

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

[1152] Step 1:

[1153] Getting User Input

[1154] The user inputs a new rule into the device interface and clicks the submit button. The input rule is "prohibit the use of smartphones during meetings." At the same time, the device's camera captures the user's emotional data. The input data and emotional data are obtained.

[1155] Step 2:

[1156] Data transmission

[1157] The device converts the acquired new rules and emotion data into JSON format and sends it to the server as an HTTP POST request. The request content includes the new rules and emotion data. The input data is the new rules and emotion data, and the output data is the HTTP request.

[1158] Step 3:

[1159] Receipt of request

[1160] The server receives the HTTP POST request, analyzes the content, extracts new rules and emotion data, and stores them in the respective variables. The input data is the HTTP request, and the output data is the new rules and emotion data.

[1161] Step 4:

[1162] Using generative models

[1163] The server inputs a prompt and a new rule into a pre-loaded generative model (e.g., OpenAI's API). Prompt: "The use of smartphones is prohibited during meetings." The generative model generates a detailed explanation based on this prompt. The explanation is "The use of smartphones is prohibited during meetings. This rule is intended to improve productivity." The input data is the prompt and the new rule, and the output data is the explanation.

[1164] Step 5:

[1165] Collision Detection

[1166] The server loads existing rules from the database and compares them with the new rule. For example, if an existing rule states, "Smartphones are allowed during meetings if there is an important message," the server detects the inconsistency. The input data is the new rule and the existing rule, and the output data is the inconsistency information.

[1167] Step 6:

[1168] Using the Emotion Engine

[1169] The server uses an emotion engine (e.g., EmotionEngine) to analyze the user's emotion data. If the emotion is recognized as "negative," it adds a note to the generated explanation saying, "This rule was established to reduce the burden on the user." The input data is the emotion data, and the output data is the corrected explanation.

[1170] Step 7:

[1171] Response Generation

[1172] The server generates a final response based on the generated description, contradiction information, and emotion information. The response is sent to the terminal in JSON format. The input data are the generated description, contradiction information, and emotion information, and the output data is the JSON format response.

[1173] Step 8:

[1174] Viewing the response

[1175] The terminal parses the JSON response received from the server and displays it to the user. The user can then check the generated explanation for any discrepancies between the explanation and existing rules, as well as supplementary explanations based on emotions. The input data is the JSON response, and the output data is displayed on the user interface.

[1176] The specific processing unit 290 transmits the result of the specific processing to the headset type terminal 314. In the headset type terminal 314, the control unit 46A causes the speaker 240 and the display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

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

[1178] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the headset type terminal 314.

[1179] [Fourth embodiment]

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

[1181] 7, a data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

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

[1183] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a control target 443. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

[1184] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

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

[1186] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[1187] The control object 443 includes a display device, LEDs in the eyes, and motors for driving the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

[1188] Fig. 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Fig. 8, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[1189] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

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

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

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

[1193] The present invention relates to a system that automatically generates and explains rules within an organization using a generative model. This system has an interface for users to input new rules, compares the new rules with existing rules, detects conflicts, and displays them to the user. Specific embodiments for implementing the present invention are described below.

[1194] System configuration

[1195] Server side

[1196] The server has the following main functions:

[1197] 1. Load Generative Model: The server loads and initializes a pre-trained generative model, which is used to generate explanations for new rules.

[1198] 2. Receiving a request: The server receives an HTTP POST request sent from the terminal, which includes the new rules entered by the user.

[1199] 3. Explanation generation using the generative model: The server inputs a new rule into the generative model and generates a detailed explanation for that rule.

[1200] 4. Conflict Detection: The server detects possible inconsistencies or conflicts between new rules and existing rules.

[1201] 5. Response generation: The server compiles the generated explanation and detected conflict information and sends it to the terminal as a JSON-formatted response.

[1202] Terminal side

[1203] The terminal has the following main features:

[1204] 1. Providing a user interface: The terminal provides an interface for the user to enter new rules, including a text box and a submit button.

[1205] 2. Obtaining user input: The terminal obtains the rules entered by the user and generates a request to send to the server.

[1206] 3. Displaying the response: The terminal analyzes the response received from the server and displays the generated explanation and conflict information to the user.

[1207] Specific examples

[1208] User operations

[1209] 1. The user enters "Prohibit use of smartphones during meetings" into the device's user interface and clicks the send button.

[1210] 2. The device converts the rules into JSON format and sends it to the server as an HTTP POST request.

[1211] Server Processing

[1212] 1. The server receives the request and extracts a new rule: "Do not use smartphones during meetings."

[1213] 2. The server inputs this rule into the generative model and generates an explanation: "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[1214] 3. The server compares the new rule with existing rules and detects any conflicts with the existing rule, "Smartphone use is permitted during meetings if there is an important message to be communicated."

[1215] 4. The server generates a JSON response containing the generated explanation and discrepancies and sends it to the device.

[1216] Terminal handling

[1217] 1. The terminal receives the response from the server and analyzes it.

[1218] 2. The device displays the analysis results to the user and notifies them, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule: Smartphone use is permitted during meetings if there is an important message to be communicated."

[1219] This system allows users to effectively receive explanations of new rules and proactively identify conflicts with existing rules, resulting in fast and efficient rule dissemination throughout the organization.

[1220] The processing flow will be explained below.

[1221] Step 1:

[1222] The user enters a new rule into the device's user interface, for example, "Do not use smartphones during meetings."

[1223] Step 2:

[1224] The user clicks the "Send" button.

[1225] Step 3:

[1226] The terminal takes the rules entered by the user and converts them into JSON format.

[1227] Step 4:

[1228] The terminal sends the converted JSON data to the server as an HTTP POST request.

[1229] Step 5:

[1230] The server receives the request sent from the terminal.

[1231] Step 6:

[1232] The server extracts the new rules from the body of the request.

[1233] Step 7:

[1234] The server inputs the extracted new rules into the generative model and generates a detailed description of the rules.

[1235] Step 8:

[1236] The server checks the new rules against existing rules to detect any inconsistencies or conflicts.

[1237] Step 9:

[1238] The server compiles the generated description and any detected conflicts into a JSON-formatted response.

[1239] Step 10:

[1240] The server sends the generated JSON response to the terminal.

[1241] Step 11:

[1242] The terminal receives the response from the server.

[1243] Step 12:

[1244] The device parses the received JSON response and extracts the generated description and collision information.

[1245] Step 13:

[1246] The terminal displays the extracted explanatory text and conflict information on a user interface.

[1247] Step 14:

[1248] The user checks the displayed content and understands the new rules, their explanations, and conflict information.

[1249] Example 1

[1250] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1251] When managing rules within an organization, there is a need to quickly detect inconsistencies and conflicts with existing rules when introducing new rules and to notify users in an easy-to-understand manner. However, when creating rules and detecting conflicts manually, there is a problem that efficient management is difficult due to the large amount of manual work required. Furthermore, automatically generating explanations for complex rules requires advanced technology, which is difficult to achieve.

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

[1253] In this invention, the server includes means for automatically generating and explaining rules within an organization using a generative model, means for receiving an HTTP POST request and inputting a new rule into the generative model, means for generating an explanation of the new rule using the generative model, means for matching the new rule with existing rules and retrieving information from a database, means for detecting conflicts between the new rule and existing rules, and means for sending the generated explanation and detected conflict information to a terminal as a JSON-formatted response. This makes it possible to automatically detect inconsistencies and conflicts with existing rules when a user introduces a new rule and notify the user quickly and clearly.

[1254] A "generative model" refers to an artificial intelligence algorithm that generates new sentences and explanations based on text data entered by a user.

[1255] "Interface" refers to a screen or device that allows a user to input information into a system.

[1256] An "HTTP POST request" is a type of protocol for sending data to a server when a user inputs a new rule.

[1257] "Database" refers to a system for storing existing rules and for searching and matching them.

[1258] "JSON format" is a format for structuring and expressing data in text format, and is an abbreviation for JavaScript Object Notation.

[1259] "Terminal" refers to an electronic device through which a user accesses and operates the system.

[1260] "Conflict detection" refers to the process of checking for conflicts or inconsistencies between new rules and existing rules.

[1261] "Response" refers to response data sent from the server to the terminal.

[1262] "Parsing" refers to the process of interpreting data received from the server and converting it into an understandable format.

[1263] This invention relates to a system that uses generative AI models to automatically generate and explain rules within an organization. The system has an interface for users to input new rules, matches the new rules with existing rules, detects conflicts, and displays them to the user.

[1264] Server-side configuration

[1265] The server has the following main functions:

[1266] 1. Load the generative model:

[1267] At system startup, the server loads a pre-trained generative AI model, such as a natural language processing model like GPT-3 or BERT, which is used to generate detailed descriptions of new rules.

[1268] 2. Receipt of Request:

[1269] The server receives an HTTP POST request from the device. The request contains the new rules entered by the user in JSON format. For example, if the user enters "prohibit the use of smartphones during meetings," the server proceeds with processing based on this information.

[1270] 3. Explanation generation using generative models:

[1271] The server inputs the new rules it has acquired into a generative AI model, which then generates a detailed explanation based on the rules. For example, if the prompt "Smartphone use is prohibited during meetings" is input into the generative model, the generated explanation will be "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[1272] 4. Collision detection:

[1273] The server checks the new rule against the existing rules, which are loaded from a database, to detect any conflicts. For example, if an existing rule states, "Smartphones are allowed during meetings if there are important communications," the server detects a conflict between the new and old rules.

[1274] 5. Response generation and transmission:

[1275] The server sends the generated description and detected collision information to the device as a JSON-formatted response.

[1276] Terminal configuration

[1277] The terminal has the following main features:

[1278] 1. Providing the user interface:

[1279] The terminal provides an interface for the user to enter new rules, which includes a text box and a submit button. The user enters the new rule through this interface and clicks the submit button.

[1280] 2. Getting user input and generating a request:

[1281] It takes the rules entered by the user, converts them into JSON format, and sends them to the server as an HTTP POST request. For example, if a user enters "prohibit the use of smartphones during meetings," this rule will be sent to the server.

[1282] 3. Receiving and Parsing Responses:

[1283] Receives the response from the server and parses it, extracting the generated description and collision information from the received JSON data.

[1284] 4. View the response:

[1285] The analysis results are displayed to the user. The user can visually see the explanation of the new rule and any conflicts with existing rules. For example, the display might say, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule 'Smartphone use is permitted during meetings if there is an important message.'"

[1286] This system allows users to effectively receive explanations of new rules and identify conflicts with existing rules in advance, which is expected to result in quick and efficient dissemination of rules throughout the organization.

[1287] Prompt Sentence Examples

[1288] "Check the new rule against existing rules and detect conflicts. New rule: 'No smartphones allowed during meetings.'"

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

[1290] Step 1: Loading the Generative Model

[1291] At system startup, the server loads a pre-trained generative AI model, such as a natural language processing model like GPT-3 or BERT. This model is needed to generate explanations for new rules. The input is the model file, and the output is the initialized generative model.

[1292] Step 2: Providing a User Interface

[1293] The terminal provides an interface for the user to enter new rules. This interface includes a text box and a submit button. As the user enters rules, new rules are generated. The input is the user's actions, and the output is the rules entered by the user.

[1294] Step 3: Getting User Input and Creating a Request

[1295] The terminal takes the new rule entered by the user in the text box, converts it to JSON format, and generates an HTTP POST request that is sent to the server, with the input being the user's input data and the output being the JSON formatted request.

[1296] Step 4: Receiving the request

[1297] The server receives an HTTP POST request sent from the device, which contains the new rules entered by the user. The input is the JSON formatted request, and the output is the parsed new rule data.

[1298] Step 5: Generative model for generating explanations

[1299] The server inputs the new rule into the generative model, which then generates a detailed explanation based on the rule. Specifically, the new rule, "No smartphones allowed during meetings," is used as the prompt to generate the explanation, "No smartphones allowed during meetings. This rule is intended to improve productivity." The input is the new rule, and the output is the generated explanation.

[1300] Step 6: Collision detection

[1301] The server loads existing rules from the database to compare the new rule with the existing rules. It checks the new rule against the existing rules to detect inconsistencies and collisions. For example, if the new rule is "Smartphones are prohibited during meetings" and the existing rule is "Smartphones are allowed during meetings if there is an important message," it detects a conflict. The input is the new rule and the existing rule data, and the output is the detected conflict information.

[1302] Step 7: Generate and send a response

[1303] The server compiles the generated explanation and the detected inconsistencies and generates a JSON-formatted response, which is sent to the device. The input is the generated explanation and the detected inconsistencies, and the output is a JSON-formatted response.

[1304] Step 8: Receiving and Parsing the Response

[1305] The terminal receives the response sent from the server and parses it. It extracts the explanation and contradiction information generated from the parsed data. The input is a JSON-formatted response, and the output is the parsed explanation and contradiction information.

[1306] Step 9: View the response

[1307] The device displays the analysis results to the user. The user can see the explanation of the new rule and any conflicts with existing rules. For example, the user receives a notification that reads, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule 'Smartphone use is permitted during meetings if there is an important message.'" The input is the analyzed data, and the output is what is displayed to the user.

[1308] (Application example 1)

[1309] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1310] When introducing new operational and safety rules in existing factories, there is a high possibility that they will conflict with existing rules. This poses a risk of compromising safety and efficiency. Additionally, the process of explaining the new rules and verifying their validity is time-consuming, making it difficult to respond quickly.

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

[1312] In this invention, the server includes means for explaining a new rule using a generative model and detecting inconsistencies therein, means for providing an interface for a user to input the new rule, and means for comparing the new rule with existing rules and detecting conflicts, thereby enabling the user to quickly receive an explanation of the new rule and immediately grasp any inconsistencies with existing rules.

[1313] A "generative model" is an algorithm that uses machine learning or deep learning to learn patterns in documents and data and generate new data and documents.

[1314] A "user" is a person or group that interacts with the system by inputting new rules and constraints.

[1315] An "interface" is the screen or part of the application that the user uses to enter new rules and that is responsible for sending the data to the server.

[1316] "Rules" are the regulations and guidelines that apply within an organization or system.

[1317] "Verification" is the process of comparing new rules with existing rules to identify differences or inconsistencies.

[1318] "Conflict" refers to a situation in which two or more rules contradict each other and are difficult to apply simultaneously.

[1319] "Conflict Information" means data or notifications that indicate conflicts that arise between new rules and existing rules.

[1320] "JSON format" is a lightweight data exchange format for expressing data in text format, and is an abbreviation for JavaScript Object Notation.

[1321] The "server" is the central processing unit that runs the generative model, generates new rule explanations, and detects inconsistencies.

[1322] A "smartphone application" is software that runs on a smartphone and is a program that has functions such as user input, communication with a server, and display of results.

[1323] This invention relates to a system that uses generative models to automatically generate and explain operational and safety rules in factories and detect conflicts with existing rules. This system consists of a smartphone application that allows users to input new rules and check the results, and a server that generates rules and detects conflicts.

[1324] Server configuration and operation

[1325] 1. Load the generative model:

[1326] The server loads and initializes a pre-trained generative model (e.g., GPT-2), which is then used to generate explanations for new rules.

[1327] 2. Receipt of Request:

[1328] The server receives an HTTP POST request sent from the user's device, which contains the new rules entered by the user.

[1329] 3. Explanation generation using generative models:

[1330] The server inputs new rules into the generative model and generates a detailed description of the rules.

[1331] 4. Collision detection:

[1332] The server checks the new rules against existing rules to detect inconsistencies and conflicts, and loads existing rules from a database to perform conflict detection based on the necessary information.

[1333] 5. Response Generation:

[1334] The server compiles the generated explanation and the detected discrepancies and sends it to the device as a JSON-formatted response.

[1335] Terminal configuration and operation

[1336] 1. Providing the user interface:

[1337] The terminal provides an interface for the user to enter new rules, which includes a text box and a submit button.

[1338] 2. Getting user input:

[1339] After the user enters a new rule, the terminal converts the rule into JSON format and sends it to the server as an HTTP POST request.

[1340] 3. View the response:

[1341] The terminal analyzes the response received from the server and displays the generated explanation and contradiction information to the user. As a concrete example, the following input and output are possible:

[1342] Specific examples

[1343] User operations

[1344] The user inputs "The speed of forklifts will be limited in designated areas. The purpose is to prevent accidents" into the user interface of the terminal and clicks the send button.

[1345] Server Processing

[1346] The server receives the request and extracts a new rule: "Limit the speed of forklifts in designated areas. The purpose is to prevent accidents."

[1347] The server inputs this rule into the generative model and generates the explanation, "Forklift speeds are limited in designated areas. This is to prevent accidents."

[1348] The server compares the new rule with existing rules and detects any inconsistencies with the existing rule that "high priority transports are performed at high speed."

[1349] The server generates a JSON response containing the generated explanation and discrepancies and sends it to the device.

[1350] Terminal handling

[1351] The terminal receives the response from the server and analyzes it.

[1352] The terminal displays the analysis results to the user, informing them, "New rule: Limit forklift speeds in designated areas. This is intended to prevent accidents. However, it may conflict with the existing rule: 'High-priority transport must be done at high speeds.'"

[1353] Prompt Sentence Examples

[1354] Example user input:

[1355] "The speed of forklifts is limited in designated areas. The purpose is to prevent accidents."

[1356] The present invention allows new rules to be smoothly introduced within the factory, and makes it possible to maintain safety and efficiency.

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

[1358] Step 1:

[1359] The terminal provides an interface for the user to input new rules. The user enters the new rule in a text box on the interface and clicks the submit button. An example of user input is "Limit the speed of forklifts in designated areas. The purpose is to prevent accidents."

[1360] Step 2:

[1361] The terminal receives the rules entered by the user and converts them into JSON format. The converted data is sent to the server as an HTTP POST request. If the new rule entered is "Limit the speed of forklifts in designated areas. The purpose is to prevent accidents," it is sent to the server as JSON data.

[1362] Step 3:

[1363] The server receives an HTTP POST request and parses the JSON data in the request. It extracts new rules from the parsed data. The server inputs the new rules into the generative model, which then generates an explanation for the rules. For example, the generative model might generate an explanation like, "Forklift speeds are limited in designated areas. This is to prevent accidents."

[1364] Step 4:

[1365] The server loads existing rules from the database to match the new rule with the existing rules. The server compares the new rule with the existing rules to detect inconsistencies and conflicts. For example, if the new rule "Limit the speed of forklifts in designated areas" conflicts with the existing rule "High-priority transport must be done at high speeds," it generates inconsistency information.

[1366] Step 5:

[1367] The server generates a response in JSON format that includes the description of the generated rule and any conflicts. For example, the generated JSON response might read, "Description: Limits the speed of forklifts in the specified area. This is to prevent accidents. Conflicting existing rule: High-priority transport must be done at high speeds."

[1368] Step 6:

[1369] The terminal parses the JSON response received from the server and displays the generated explanation and conflict information to the user. Specifically, it notifies the user that "New rule: Limit the speed of forklifts in designated areas. This is intended to prevent accidents. However, this may conflict with the existing rule 'High-priority transport should be done at high speeds.'"

[1370] By following these steps, the user can accurately input a new rule and quickly understand the rule's description and any inconsistencies with existing rules.

[1371] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1372] This invention combines an emotion engine with a system that uses generative models to automatically generate and explain rules within an organization. The system has an interface for users to input new rules, matches the new rules with existing rules, detects conflicts, and uses the emotion engine to recognize the user's emotional state and adjust the rule generation and explanation content based on that.

[1373] System configuration

[1374] Server side

[1375] The server has the following main functions:

[1376] 1. Loading the Generative Model: The server loads and initializes a pre-trained generative model, which is used to generate explanations for new rules.

[1377] 2. Receiving the request: The server receives the HTTP POST request sent from the terminal and extracts the new rules entered by the user.

[1378] 3. Explanation generation using the generative model: The server inputs the new rule into the generative model and generates a detailed explanation for the rule.

[1379] 4. Conflict detection: The server checks the new rules against existing rules to detect inconsistencies or conflicts.

[1380] 5. Use of Emotion Engine: The server uses the emotion engine to analyze the user's emotional state and adjusts the explanation and display of the rule based on that information.

[1381] 6. Response generation: The server compiles the generated explanation, conflict information, and adjustments based on emotion information into a JSON-formatted response and sends it to the device.

[1382] Terminal side

[1383] The terminal has the following main features:

[1384] 1. Providing a user interface: The terminal provides an interface for the user to enter new rules, including a text box and a submit button.

[1385] 2. Obtaining user input: The terminal obtains the rules entered by the user and generates a request to send to the server.

[1386] 3. Acquiring emotional information: The device acquires the user's emotions using sensors such as a camera and sends them to the server.

[1387] 4. Displaying the response: The terminal analyzes the response received from the server and displays the generated explanation, conflict information, and adjustments based on the emotion information to the user.

[1388] Specific examples

[1389] User operations

[1390] 1. The user enters "Prohibit use of smartphones during meetings" into the device's user interface and clicks the send button.

[1391] 2. The device converts the rules into JSON format, obtains the user's emotional state, and sends them to the server as an HTTP POST request.

[1392] Server Processing

[1393] 1. The server receives the request and extracts the new rule "prohibit smartphone use during meetings" and emotion data.

[1394] 2. The server inputs this rule into the generative model and generates an explanation: "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[1395] 3. The server compares the new rule with existing rules and detects any conflicts with the existing rule, "Smartphone use is permitted during meetings if there is an important message to be communicated."

[1396] 4. The server uses an emotion engine to analyze the user's emotional state and adjust the content and presentation of the explanation accordingly. For example, if the user is expressing disapproval, the explanation will be softened.

[1397] 5. The server sends a JSON response to the device containing the generated explanation, discrepancies, and information adjusted based on the emotion information.

[1398] Terminal handling

[1399] 1. The device receives the response from the server and analyzes it.

[1400] 2. The device displays the analysis results on the user interface and notifies the user, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule, 'Smartphone use is permitted during meetings if there is important communication to be made.' This rule has been established to improve efficiency across the organization."

[1401] This system allows users to effectively receive explanations of new rules and proactively identify conflicts with existing rules. Furthermore, the system dynamically adjusts the explanation and presentation of rules according to the user's emotional state, making it possible to communicate rules in a more acceptable manner.

[1402] The processing flow will be explained below.

[1403] Step 1:

[1404] The user enters a new rule into the device's user interface, for example, "Do not use smartphones during meetings."

[1405] Step 2:

[1406] The user provides their emotional state (e.g., facial expression or tone of voice) through sensors such as a camera or microphone on the device, which the device then captures as emotion data.

[1407] Step 3:

[1408] The user clicks the "Send" button.

[1409] Step 4:

[1410] The device receives the rules entered by the user and converts them into JSON format, as well as the emotion data.

[1411] Step 5:

[1412] The device sends an HTTP POST request containing the converted rules and emotion data to the server.

[1413] Step 6:

[1414] The server receives the request sent from the terminal.

[1415] Step 7:

[1416] The server extracts the new rules and emotion data from the body of the request.

[1417] Step 8:

[1418] The server inputs the extracted new rule into the generative model and generates a detailed explanation of the rule, for example, "The use of smartphones during meetings is prohibited. This rule is intended to improve productivity."

[1419] Step 9:

[1420] The server checks the new rule against existing rules to detect any inconsistencies or conflicts, such as a conflict with an existing rule that says, "Smartphones are allowed during meetings if there is an important message to be sent."

[1421] Step 10:

[1422] The server uses an emotion engine to analyze the user's emotional state, for example, the emotion engine determines that the user is expressing dislike.

[1423] Step 11:

[1424] The server adjusts the explanation and presentation of the rule based on the results of the emotion engine's analysis. For example, if the user expresses dislike, the explanation will be presented in a gentler way.

[1425] Step 12:

[1426] The server generates a JSON response containing the adjusted description, detected collision information, and emotion information.

[1427] Step 13:

[1428] The server sends the generated JSON response to the device.

[1429] Step 14:

[1430] The terminal receives the response from the server.

[1431] Step 15:

[1432] The device analyzes the received JSON response and extracts adjustments based on the generated description, conflict information, and emotion information.

[1433] Step 16:

[1434] The device displays the extracted explanation, conflict information, and adjustment details on the user interface. For example, it might say, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule, 'Smartphone use is permitted during meetings if there is an important message to be communicated.' This rule was established to improve efficiency across the organization."

[1435] Step 17:

[1436] The user checks the displayed content and understands the new rules and their explanations, as well as the collision information and their adjustments.

[1437] Example 2

[1438] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1439] When formulating new rules within an organization, it was difficult to detect conflicts with existing rules in advance and clearly explain the conflicts. Furthermore, it was not possible to appropriately adjust the explanation based on the user's emotional state, which could lead to user resistance and confusion.

[1440] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes means for automatically generating and explaining rules within an organization using a generative model, means for providing an interface for a user to input a new rule, means for matching the new rule with existing rules and detecting conflicts, means for analyzing the emotional state of the user using an emotion engine and adjusting the explanation and display method of the generated rule based on the analysis results, and means for displaying the detected conflict information and the adjusted explanation of the rule to the user. This makes it possible to automatically and effectively generate new rules and explain conflicts with existing rules, and further to adjust the content of the explanation according to the emotional state of the user.

[1441] A "generative model" is an artificial intelligence technique that uses pre-trained algorithms to generate new rules and text.

[1442] "Organizational rules" refer to the rules and guidelines that employees and members must follow within an organization.

[1443] "Interface" refers to the means of providing a screen and input methods to enable interaction between a user and a system.

[1444] "Conflict detection" refers to the process of comparing new rules with existing rules to identify contradictions or inconsistencies.

[1445] An "emotion engine" refers to artificial intelligence technology for analyzing a user's emotional state, and has the ability to read emotions primarily from facial expressions and tone of voice.

[1446] "Emotional state" refers to a user's psychological response or emotional state at a particular moment.

[1447] "JSON format" stands for JavaScript Object Notation and refers to a text-based format for structuring and transferring data.

[1448] An "HTTP POST request" is one of the Internet protocols and refers to a request format for sending data to a server.

[1449] The present invention combines an emotion engine with a system that uses generative models to automatically generate and explain rules within an organization. The system provides an interface for users to input new rules, matches the new rules with existing rules to detect conflicts, and uses the emotion engine to recognize the user's emotional state and adjust the rule generation and explanation content accordingly.

[1450] Specific processing on the server side

[1451] 1. Load the generative model:

[1452] The server loads and initializes a pre-trained generative model (e.g., a general generative AI model), which is used to generate explanations for new rules, and deploys the model in the server's memory and makes it accessible through an API interface.

[1453] 2. Receipt of Request:

[1454] The server receives an HTTP POST request from the device. This request contains the new rules entered by the user in JSON format. For example, if the user enters "prohibit the use of smartphones during meetings," the server receives a request containing that rule.

[1455] 3. Explanation generation using generative models:

[1456] The server inputs the new rule into the generative model and generates a detailed explanation for the rule. The generative model generates an explanation by providing a prompt such as "New rule: XX. The reason is...". An explanation such as "Smartphone use is prohibited during meetings. This rule is intended to improve productivity" can be generated.

[1457] 4. Collision detection:

[1458] The server compares the new rule with existing rules to detect any inconsistencies or conflicts. For example, it analyzes the inconsistencies with an existing rule such as "Smartphones are allowed during meetings if there is an important message to be sent."

[1459] 5. Use of Emotion Engine:

[1460] The server uses an emotion engine (e.g., general emotion recognition software) to analyze the user's emotional data. Based on this data, it adjusts the rule explanation and display method. If the user shows resentment, it changes the wording to a softer one.

[1461] 6. Response Generation:

[1462] The server compiles the generated explanation, conflict information between the new rule and the existing rule, and information adjusted based on the emotional state as a JSON response, and sends this response to the device via HTTP POST.

[1463] Specific processing on the terminal side

[1464] 1. Providing the user interface:

[1465] The terminal provides an interface (e.g., a web page with text boxes and a submit button) for the user to enter new rules. Arrange the fields to make it easy for the user to enter them.

[1466] 2. Getting user input:

[1467] The terminal takes the rules entered by the user in the text box and converts them into JSON format, which includes metadata such as the rule content and timestamp.

[1468] 3. Acquiring emotional information:

[1469] The device uses cameras and other sensors to capture user emotion data, for example, by using facial recognition technology to analyze emotions from the user's facial expressions and add the data to a JSON format.

[1470] 4. View the response:

[1471] The device analyzes the response received from the server and displays the generated explanation, conflict information between the new rule and the existing rule, and content adjusted based on the user's emotional state. The information is displayed visually in a pop-up or modal window.

[1472] Specific examples

[1473] User operations

[1474] 1. The user enters "Prohibit smartphone use during meetings" into the device interface and clicks the send button.

[1475] 2. The device converts the rules entered by the user into JSON format and sends it to the server as an HTTP POST request along with the emotion data acquired by the facial recognition sensor.

[1476] Server Processing

[1477] 1. The server receives the request and extracts the new rule "prohibit smartphone use during meetings" and emotion data.

[1478] 2. The server inputs this rule into the generative model and generates the explanation, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[1479] 3. The server compares the new rule with existing rules and detects any inconsistencies with the existing rule, "Smartphones are allowed during meetings if there is an important message to be communicated."

[1480] 4. The server uses an emotion engine to analyze the user's emotional state, and if the user is showing resentment, adjusts the statement to a softer one, such as "The new rules are necessary to improve the efficiency of the entire organization."

[1481] 5. The server sends a JSON response to the device, including the generated description, collision points, and information adjusted based on emotion information.

[1482] Terminal handling

[1483] 1. The device receives the response from the server and analyzes it.

[1484] 2. The device displays the analysis results on the user interface and notifies users, for example, "New rule: Smartphone use is prohibited during meetings. This rule is intended to improve productivity. However, it may conflict with the existing rule, 'Smartphone use is permitted during meetings if there is an important message to be communicated.' This rule has been established to improve efficiency across the organization."

[1485] The system allows users to receive detailed explanations of new rules and proactively identify conflicts with existing rules. Furthermore, the explanations are tailored to the user's emotional state, making it possible to present rules in a more acceptable format.

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

[1487] Step 1: Loading the Generative Model

[1488] The server loads pre-trained generative models and makes them accessible through an API interface. As input, it receives the file path and configuration information of the required model. The server loads this in memory and initializes it. As output, the generative model is ready to use.

[1489] Step 2: Receiving the request

[1490] The device provides an interface (e.g., a text box) where the user enters a new rule. The user initiates the request by entering "ban smartphones during meetings" and clicking the submit button. The server receives an HTTP POST request from the device. The input contains the new rule entered by the user in JSON format. The server parses the request and extracts the content of the new rule. The output is the text of the new rule.

[1491] Step 3: Generative model for generating explanations

[1492] The server inputs the new rule text into the generative model and generates a detailed explanation for that rule. The generative model generates an explanation by giving a prompt such as "New rule: XX. The reason is...". The text of the new rule is given as input, and the generated explanation is obtained as output.

[1493] Step 4: Collision detection

[1494] The server checks the new rule against existing rules to find inconsistencies and conflicts. Existing rules are loaded from a database. As input, the text of the new rule and the data of the existing rule are given. The server compares them and identifies conflicts. As output, it gets a list of conflicts.

[1495] Step 5: Use the Emotion Engine

[1496] The device uses a camera and other sensors to capture the user's emotional data and sends it to the server. The server then uses an emotion engine to analyze the user's emotional state. The user's emotional data is given as input, and the analysis results are obtained as output, which are used to adjust the explanation.

[1497] Step 6: Response Generation

[1498] The server compiles the generated description, conflict information between new rules and existing rules, and information adjusted based on the emotional state, and generates a response in JSON format. The input is the generated description, a list of conflict points, and the emotion analysis results. The server integrates these and generates response data as output, which is sent to the terminal as an HTTP response.

[1499] Step 7: View the response

[1500] The device parses the JSON response received from the server and displays information to the user in a visually understandable way. The response data received from the server is given as input. The device parses it and checks the generated explanation, conflict information between new rules and existing rules, and adjustments based on the emotional state. The output is the content displayed in the user interface.

[1501] (Application example 2)

[1502] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1503] Typically, creating and explaining rules within an organization is done manually, which requires a great deal of effort and time. Furthermore, when contradictions or conflicts arise between rules, the process of detecting and resolving them is complicated. Explaining and displaying rules in a way that is emotionally receptive to users is even more difficult. In particular, virtual stores are used by a diverse range of users, so individual, appropriate responses are required. The objective of this invention is to solve these problems and provide a system that automatically generates and explains rules and optimally displays them, taking into account the user's emotional state.

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

[1505] In this invention, the server includes: means for automatically generating and explaining rules within an organization using a generative model; means for providing an interface for a user to input a new rule; means for comparing the new rule with existing rules and detecting conflicts; means for displaying detected conflict information to the user; means for recognizing the user's emotional state using an emotion engine and adjusting the explanation and display content based on the emotional state; and means for adjusting prompt sentences based on the user's emotional state when generating a new rule explanation. This makes it possible to automatically and dynamically explain and display rules to a variety of users and provide optimal responses according to their emotions.

[1506] A "generative model" is an artificial intelligence technology that generates new information based on previously learned data.

[1507] "Organizational rules" refer to instructions and regulations set within a particular organization or group.

[1508] An "emotion engine" is a system that recognizes a user's emotional state by analyzing their facial expressions, voice, and other data.

[1509] An "interface" is the means or medium through which a user accesses and operates a system.

[1510] "Matching" is the act of comparing two or more pieces of data to see if they match.

[1511] Detecting a "conflict" means discovering whether a new rule that is generated contradicts an existing rule.

[1512] "Adjust" refers to changing or optimizing content for specific conditions or circumstances.

[1513] A "prompt sentence" is a basic sentence or instruction that serves as input to a generative model.

[1514] This invention is a system that automatically generates and explains rules within an organization using a generative model and an emotion engine. The system provides an interface for inputting new rules, generates detailed explanations using the generative model, detects conflicts with existing rules, and adjusts the explanations and display content based on the user's emotional state.

[1515] Server-side configuration

[1516] The server has the following main functions:

[1517] 1. Loading a Generative Model: The server loads and initializes a pre-trained generative model (e.g., OpenAI's API). This generative model receives a prompt to explain the new rule as input and generates a detailed explanation.

[1518] 2. Receiving a request: The server receives the HTTP POST request sent from the device and extracts the new rules and emotion data entered by the user.

[1519] 3. Explanation generation: The server inputs the new rule into the generative model and generates a detailed explanation based on the user's sentiment. For example, if a user inputs "Smartphone use is prohibited during meetings," the generative model generates the explanation "Smartphone use is prohibited during meetings. This rule is intended to improve productivity."

[1520] 4. Conflict detection: The server loads the new rule and the existing rule from the database and compares them to detect any inconsistencies or conflicts. For example, if an existing rule states, "Smartphones are allowed during meetings if there are important communications," a conflict will be detected.

[1521] 5. Use of Emotion Engine: The server uses an emotion engine (e.g., EmotionEngine) to analyze the user's emotional state and adjust the generated explanation based on that information. For example, if the user expresses dislike, it adds the explanation, "In addition, this rule was established to reduce the burden on the user."

[1522] 6. Response generation: The server compiles the generated explanation, contradiction information, and adjustments based on emotion information into a JSON-formatted response and sends it to the device.

[1523] Terminal configuration

[1524] The terminal has the following main features:

[1525] 1. Providing an interface: The terminal provides an interface (e.g., a text box and a submit button) for the user to input new rules.

[1526] 2. Obtaining user input: The device obtains the rules entered by the user and analyzes the user's emotional state using sensors such as a camera.

[1527] 3. Data transmission: The device converts the new rules and emotion information into JSON format and sends it to the server as an HTTP POST request.

[1528] 4. Displaying the response: The terminal analyzes the response received from the server and displays the generated explanation, conflict information, and adjustments based on the emotion information to the user.

[1529] Specific example explanation

[1530] The user enters "Smartphone use is prohibited during meetings" into the device interface and clicks the send button. The device converts the rule into JSON format, obtains the user's emotional state, and sends them to the server as an HTTP POST request. The server receives the request and extracts the new rule "Smartphone use is prohibited during meetings" and emotional data. This rule is input into the generative model, and an explanation is generated: "Smartphone use is prohibited during meetings. This rule is intended to improve productivity." A contradiction with the existing rule "Smartphone use is permitted during meetings if there is an important message to be communicated." The emotion engine also analyzes the user's emotional state, and if it is determined to be "negative," a correction is made: "In addition, this rule has been established to reduce the user's burden." Finally, the generated explanation and contradictions are sent to the device in JSON format and displayed to the user.

[1531] Prompt Sentence Examples

[1532] Please generate detailed explanations for the following rules:

[1533] ---

[1534] Rule: "No smartphones allowed during meetings."

[1535] ---

[1536] Detailed Description:

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

[1538] Step 1:

[1539] Getting User Input

[1540] The user inputs a new rule into the device interface and clicks the submit button. The input rule is "prohibit the use of smartphones during meetings." At the same time, the device's camera captures the user's emotional data. The input data and emotional data are obtained.

[1541] Step 2:

[1542] Data transmission

[1543] The device converts the acquired new rules and emotion data into JSON format and sends it to the server as an HTTP POST request. The request content includes the new rules and emotion data. The input data is the new rules and emotion data, and the output data is the HTTP request.

[1544] Step 3:

[1545] Receipt of request

[1546] The server receives the HTTP POST request, analyzes the content, extracts new rules and emotion data, and stores them in the respective variables. The input data is the HTTP request, and the output data is the new rules and emotion data.

[1547] Step 4:

[1548] Using generative models

[1549] The server inputs a prompt and a new rule into a pre-loaded generative model (e.g., OpenAI's API). Prompt: "The use of smartphones is prohibited during meetings." The generative model generates a detailed explanation based on this prompt. The explanation is "The use of smartphones is prohibited during meetings. This rule is intended to improve productivity." The input data is the prompt and the new rule, and the output data is the explanation.

[1550] Step 5:

[1551] Collision Detection

[1552] The server loads existing rules from the database and compares them with the new rule. For example, if an existing rule states, "Smartphones are allowed during meetings if there is an important message," the server detects the inconsistency. The input data is the new rule and the existing rule, and the output data is the inconsistency information.

[1553] Step 6:

[1554] Using the Emotion Engine

[1555] The server uses an emotion engine (e.g., EmotionEngine) to analyze the user's emotion data. If the emotion is recognized as "negative," it adds a note to the generated explanation saying, "This rule was established to reduce the burden on the user." The input data is the emotion data, and the output data is the corrected explanation.

[1556] Step 7:

[1557] Response Generation

[1558] The server generates a final response based on the generated description, contradiction information, and emotion information. The response is sent to the terminal in JSON format. The input data are the generated description, contradiction information, and emotion information, and the output data is the JSON format response.

[1559] Step 8:

[1560] Viewing the response

[1561] The terminal parses the JSON response received from the server and displays it to the user. The user can then check the generated explanation for any discrepancies between the explanation and existing rules, as well as supplementary explanations based on emotions. The input data is the JSON response, and the output data is displayed on the user interface.

[1562] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

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

[1564] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the robot 414.

[1565] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1566] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1567] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1568] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1569] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1570] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1571] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1572] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1573] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1574] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1575] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1576] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1577] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1578] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1579] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1580] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1581] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1582] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1583] The following is further disclosed regarding the above embodiment.

[1584] (Claim 1)

[1585] A means of automatically generating and explaining rules within an organization using generative models;

[1586] means for providing an interface for a user to input new rules;

[1587] a means of matching new rules with existing rules and detecting conflicts;

[1588] means for displaying detected collision information to a user;

[1589] A system that includes...

[1590] (Claim 2)

[1591] 10. The system of claim 1, wherein new rules are generated based on the generative model and an explanation of the rules is provided to the user.

[1592] (Claim 3)

[1593] 10. The system of claim 1, wherein upon detecting a conflict between the new rule and an existing rule, the existing rule is loaded from the database.

[1594] "Example 1"

[1595] (Claim 1)

[1596] A means of automatically generating and explaining rules within an organization using generative models;

[1597] means for providing an interface for a user to input new rules;

[1598] A means of receiving HTTP POST requests to input new rules into the generative model;

[1599] a means for generating new rule explanations using a generative model;

[1600] A means of matching new rules with existing rules and retrieving information from a database;

[1601] a means for detecting conflicts between new rules and existing rules;

[1602] A means for sending the generated description and detected collision information to the terminal as a JSON format response;

[1603] A means for receiving a response from the server, analyzing it, and displaying it to the user;

[1604] A system including:

[1605] (Claim 2)

[1606] 10. The system of claim 1, wherein new rules are generated based on the generative model and an explanation of the rules is provided to the user.

[1607] (Claim 3)

[1608] 10. The system of claim 1, wherein upon detecting a conflict between the new rule and an existing rule, the existing rule is loaded from the database.

[1609] "Application Example 1"

[1610] (Claim 1)

[1611] A means of automatically generating and explaining rules within an organization using generative models;

[1612] means for providing an interface for a user to input new rules;

[1613] a means of matching new rules with existing rules and detecting conflicts;

[1614] means for displaying detected collision information to a user;

[1615] A means for automatically reporting conflicts between new rules and existing rules;

[1616] A means to send the entered new rules and their descriptions to the server in JSON format,

[1617] A means for the server to explain new rules with a pre-trained generative model, detect inconsistencies, and generate responses;

[1618] means for providing a smartphone application for providing the generated explanations and discrepancies to a user;

[1619] A system that includes...

[1620] (Claim 2)

[1621] 2. The system according to claim 1, further comprising: means for generating new rules based on the generative model and providing an explanation of the rules to a user; and means for detecting inconsistencies between the new rules and existing rules.

[1622] (Claim 3)

[1623] 2. The system according to claim 1, wherein when detecting a conflict between a new rule and an existing rule, the system loads the existing rule from a database and has a function of detecting a conflict based on information stored in the database.

[1624] "Example 2: Combining Emotion Engines"

[1625] (Claim 1)

[1626] A means of automatically generating and explaining rules within an organization using generative models;

[1627] means for providing an interface for a user to input new rules;

[1628] a means of matching new rules with existing rules and detecting conflicts;

[1629] a means for analyzing the user's emotional state using an emotion engine and adjusting the explanation and display method of the generated rule based on the analysis result;

[1630] means for displaying the detected conflict information and an explanation of the adjusted rules to the user;

[1631] A system including:

[1632] (Claim 2)

[1633] 2. The system according to claim 1, wherein new rules are generated based on a generative model, an explanation of the rules is provided to the user, and the content of the explanation is adjusted according to the user's emotions using an emotion engine.

[1634] (Claim 3)

[1635] 2. The system according to claim 1, wherein when detecting a conflict between a new rule and an existing rule, the system loads the existing rule from a database and provides adjusted information based on the result of the rule and the result of sentiment analysis.

[1636] "Application example 2 when combining emotion engines"

[1637] (Claim 1)

[1638] A means of automatically generating and explaining rules within an organization using generative models;

[1639] means for providing an interface for a user to input new rules;

[1640] a means of matching new rules with existing rules and detecting conflicts;

[1641] means for displaying detected collision information to a user;

[1642] means for recognizing a user's emotional state using an emotion engine and adjusting the explanation and display content accordingly;

[1643] means for adjusting prompt sentences based on the emotional state of the user when generating new rule explanations;

[1644] A system that includes...

[1645] (Claim 2)

[1646] 10. The system of claim 1, wherein new rules are generated based on the generative model and an explanation of the rules is provided to the user.

[1647] (Claim 3)

[1648] 10. The system of claim 1, wherein upon detecting a conflict between the new rule and an existing rule, the existing rule is loaded from the database. [Explanation of symbols]

[1649] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. A means to automatically generate and explain rules within an organization using generative models; means for providing an interface for a user to input new rules; a means of matching new rules with existing rules and detecting conflicts; means for displaying detected collision information to a user; A system including:

2. The system of claim 1 , wherein the system generates new rules based on the generative model and provides explanations of the rules to a user.

3. 2. The system of claim 1, wherein upon detecting a conflict between a new rule and an existing rule, the existing rule is loaded from the database.

Images