System

Abstract

A system is provided.SOLUTION: A system comprising: means for including a natural language processing model for detecting typographical errors; means for extracting an amount described in a credit application from an estimate; means for comparing the amount described in the credit application with the amount extracted from the estimate; means for generating an error message based on a result of the comparison; and means for presenting the error message 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 process of creating and approving approval requests involves problems such as typos, incorrect input of amounts based on estimates, and the time and effort required for the request initiator and approver to understand the approval status of similar requests in the past. This poses a challenge, making it difficult to improve the quality of approval requests while making decisions efficiently. As a result, work efficiency declines and the risk of incorrect decision-making increases. Another problem is that correcting errors and verifying information requires a lot of time and effort. [Means for solving the problem]

[0005] The present invention provides a system including a means for detecting typos and omissions, a means for extracting the amount stated in a request form from an estimate, a means for comparing the amount stated in the request form with the amount extracted from the estimate, a means for generating an error message based on the comparison results, and a means for presenting the error message to a user. Furthermore, by including a means for transmitting the contents of the request form and receiving the results after being checked by the typo detection means and the amount extraction means, the system detects typos and amount input errors by the drafter in advance and prompts the drafter to correct them. The system also includes a means for searching past request form data, a means for extracting similar request forms from the search results, and a means for presenting the approval results of the extracted request forms, thereby supporting accurate decision-making by referring to past cases. This improves the efficiency and accuracy of the request form drafting and approval process.

[0006] The "natural language processing model for detecting typos and omissions" is an algorithm that uses natural language processing technology to detect typos, omissions, and grammatical errors in the text data within a request form.

[0007] "Means for extracting the amount stated in the request form from the quotation" refers to a function for extracting the amount information stated in the quotation using optical character recognition (OCR) technology or other data analysis technology, and comparing it with the amount stated in the request form.

[0008] "Means for comparing the amount stated in the request form with the amount extracted from the quotation" is a function that compares the amount information stated in the request form with the amount information extracted from the quotation and performs processing to confirm consistency.

[0009] The "means for generating an error message" is a function that automatically creates an error message and notifies the user if there is an error in the contents of the approval request form.

[0010] The "means for presenting an error message to the user" is a function for displaying the generated error message on the screen of the user's device and providing the content of the error and instructions for correction.

[0011] The "natural language processing model for searching past approval request data" is an algorithm that uses natural language processing technology to analyze approval request data submitted in the past and search for approval requests with similar content.

[0012] "Means for extracting similar approval documents from search results" refers to a function for selecting approval documents with similar content and amounts from the approval document data searched by the natural language processing model.

[0013] "Means for presenting the decision results of extracted approval documents" is a function that displays the decision results (approval, rejection, etc.) of extracted past approval documents to the user and provides them as reference information. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0022] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0035] This invention is a system to support the drafter and approver of approval requests, and mainly provides functions for checking for typos, confirming amounts, and referencing past approval request data. This system utilizes AI technology, natural language processing (NLP) and optical character recognition (OCR) technologies to provide an efficient and accurate approval process.

[0036] Proposer Support System

[0037] The user enters the details of the approval request into the terminal. This includes the project name, objectives, budget, and required documents. The terminal then sends this information to the server, where a natural language processing model is used to check for typos and grammatical errors. For example, if the user enters "new product development" but misspells "new parts development," the AI ​​model detects this and generates correction suggestions. Furthermore, the content of the estimate attached to the approval request (e.g., "¥500,000") is extracted using OCR technology and compared with the amount entered in the approval request (e.g., "¥50,000"). If an error is found, the server generates an error message ("Typo detected: 'New parts development' → 'New product development'. Amount input error: '¥50,000' → '¥500,000'") and sends it to the terminal. The user can then review the error message and correct the approval request.

[0038] Decision maker support system

[0039] The decision maker enters the details of a newly received approval document into their terminal. This information is sent to the server, which searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. For example, if five approval documents related to "new product development" have been found in the past, the server obtains the approval results (two approved, three rejected) and displays them on the decision maker's terminal. This allows the decision maker to make quick and accurate decisions based on past examples.

[0040] As a specific example, when a user creates a request for approval for a "new product development budget application," the system checks for typos and omissions and confirms that the amount matches the estimate. The system also allows the approver to refer to the approval results of similar requests in the past, making the process more efficient. In this way, the present invention supports the approval process, improving work efficiency and accuracy.

[0041] The processing flow will be explained below.

[0042] Proposer Support System

[0043] Program processing

[0044] Step 1:

[0045] The user enters the contents of the request form into the terminal.

[0046] The user enters information such as the project name, purpose, budget amount, and required documents into the approval form.

[0047] Step 2:

[0048] The terminal sends the entered approval request details to the server.

[0049] The terminal sends the request data to the server via the API using a POST request.

[0050] Step 3:

[0051] The server uses a natural language processing model to check the approval request for spelling and grammatical errors.

[0052] The server inputs the request text into a natural language processing (NLP) model to detect and point out typos and grammatical errors.

[0053] Step 4:

[0054] The server reads the contents of the quotation attached to the request form.

[0055] The server uses optical character recognition (OCR) technology to extract the amount from the quotation and compare it with the amount in the approval document.

[0056] Step 5:

[0057] The server compares the amount stated in the request with the amount extracted from the quotation.

[0058] The server compares the extracted amount information with the amount information on the request form to confirm that they match.

[0059] Step 6:

[0060] The server generates an error message based on the comparison.

[0061] If the server detects an error, it creates an error message and cleans up the contents.

[0062] Step 7:

[0063] Sends any server-generated error messages to the terminal for display to the user.

[0064] The server returns an error message in JSON format to the terminal, and the terminal displays the error message in the user interface (UI).

[0065] Step 8:

[0066] The user corrects the request according to the error message.

[0067] The user checks the error message displayed on the device, corrects the contents of the approval request, and sends the corrected version to the server again.

[0068] ---

[0069] Decision maker support system

[0070] Program processing

[0071] Step 1:

[0072] The approver enters the contents of the newly received request into the terminal.

[0073] The approver enters the newly received approval information into the approval form. Example: Project name: "New product development" "Budget: ¥500,000"

[0074] Step 2:

[0075] The terminal sends the contents of the request to the server.

[0076] The terminal sends the request data to the server via the API using a POST request.

[0077] Step 3:

[0078] The server searches for similar requests from a database of past requests.

[0079] The server inputs the details of the request (project name, budget, purpose, etc.) into a natural language processing (NLP) model and searches the database.

[0080] Step 4:

[0081] The server extracts similar approval documents from the search results.

[0082] The server filters past requests based on attributes such as amount, project content, and submitting department, and lists the most matching data.

[0083] Step 5:

[0084] The server obtains the approval results of the extracted past approval documents.

[0085] The server obtains the decision results (approval, rejection, etc.) of the extracted proposals and organizes them along with any error messages.

[0086] Step 6:

[0087] The server sends the approval status of past approval requests to the terminal and presents it to the approver.

[0088] The server returns the approval status in JSON format to the terminal, and the terminal displays the information on the UI.

[0089] Example 1

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

[0091] In the conventional approval process, the proposer had to manually check the approval document for typos and grammatical errors, and also manually check for discrepancies between the amount listed on the estimate and the amount listed on the approval document. This made it prone to errors and increased the likelihood of delays in the approval process. Furthermore, the approver had to manually search past approval document data and refer to the approval results of similar approval documents, making it difficult to make efficient decisions. A solution to these problems was needed.

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

[0093] In this invention, the server includes: a means for a user to input the contents of a request form into a terminal and the terminal transmits this information to the server; a means including a natural language processing model for detecting typographical errors; optical character recognition means for extracting the amount stated in the request form from an estimate; means for comparing the amount stated in the request form with the amount extracted from the estimate; means for generating an error message based on the comparison result; and means for presenting the error message to the user. This allows the drafter to automatically detect and correct typographical errors and discrepancies in the amount in the request form, thereby realizing an efficient and error-free request process. The server also includes a means including a natural language processing model for searching past request form data; means for extracting similar request forms from the search results; and means for presenting the approval results of the extracted request forms. This allows the decision maker to quickly refer to data on similar past request forms and make decisions efficiently.

[0094] A "user" is someone who inputs the contents of a request form and checks error messages from the system.

[0095] A "terminal" is an electronic device that a user uses to input the contents of a request form and exchange information with a server.

[0096] A "server" is a central processing unit that receives information sent by a user, processes it, and returns the results to the terminal.

[0097] A "requisition form" is a document that lists the project name, purpose, budget amount, and required documents, and is used for approval procedures within a company.

[0098] A "natural language processing model" is a machine learning model that analyzes text data to detect typos and grammatical errors.

[0099] "Typographical errors" refer to typos or input errors contained in the text content of a request form.

[0100] "Optical character recognition" is a technology that extracts character information from images or documents such as PDF files.

[0101] An "quote" is a document that lists the budget amount and detailed expenses, and is attached to a request form.

[0102] The "comparison method" is a method for comparing the amount stated in the request form with the amount extracted from the estimate to determine whether they match or not.

[0103] An "error message" is information that notifies the user of problems with the request form, such as typos or mismatched amounts.

[0104] The "search method" is a technology for searching past approval request data from a database.

[0105] A "similar request form" is a past request form whose content is similar to that of the current request form.

[0106] "Decision result" refers to the result of approval or rejection of a past request for approval.

[0107] This invention is a system to support the drafter and approver of approval requests, primarily by checking for typos, confirming amounts, and providing functions for referencing past approval request data. The system utilizes AI technology, natural language processing (NLP) and optical character recognition (OCR) technologies, to provide an efficient and accurate approval process.

[0108] First, the user inputs the details of the request into the device. This information includes the project name, purpose, budget, and required documents. The device then sends this information to the server, which uses a natural language processing model (e.g., BERT or GPT-3) to check for typos and grammatical errors.

[0109] For example, if a user accidentally types "new product development" instead of "new parts development," the AI ​​model detects the error and generates the correct spelling, "new product development," as a correction suggestion. Also, when a user uploads a quote (e.g., a PDF file) attached to a request form to their device, the quote is sent from the device to the server. The server uses OCR technology (e.g., Tesseract OCR) to extract the amount information from the quote. The server compares the extracted amount (e.g., "¥500,000") with the amount written in the request form (e.g., "¥50,000") and generates a correction suggestion if there is an error.

[0110] The server compiles these correction suggestions and generates an error message (e.g., "Typo detected: 'New parts development' → 'New product development'. Amount input error: '￥50,000' → '￥500,000'.") and sends it to the terminal. The user can check the error message and correct the approval request.

[0111] Next, the approver enters the details of the newly received approval document into their terminal and sends it to the server. The server uses a natural language processing model to search a database of past approval documents, searching for past approval documents with similar amounts, project details, and submitting departments. For example, if five past approval documents related to "new product development" are found, the server obtains the approval results (two approved, three rejected) and displays them on the approver's terminal. This enables the approver to make quick and accurate decisions based on past examples.

[0112] An example of a specific prompt is:

[0113] 1. Typo detection: "Detect typos in this text: New parts development"

[0114] 2. OCR processing of quote: "Please extract the amount from this PDF file"

[0115] 3. Search for similar approval documents: "Search for past approval documents similar to the following: Project name = New product development, Budget = ¥500,000"

[0116] This system allows users and decision makers to work efficiently and accurately during the approval process, minimizing errors.

[0117] In this way, the present invention is a system that supports the process of drafting and approving requests, and aims to improve the efficiency and accuracy of business operations.

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

[0119] Proposer Support System

[0120] Step 1:

[0121] The user enters the details of the approval request.

[0122] Input: Project name, purpose, budget amount, required documents, and other information on the approval request

[0123] Output: Input information is saved to the terminal

[0124] The user enters the project name (e.g., "New product development"), purpose (e.g., "Market expansion"), budget amount (e.g., "500,000 yen"), and required documents (e.g., "Quote") into a form on the device. The device converts the input data into JSON format and sends it to the server.

[0125] Step 2:

[0126] The device sends the input information to the server

[0127] Input: Approval information entered by the user on the device (JSON format)

[0128] Output: Approval information sent to the server

[0129] The device converts the user's input into JSON format and sends it to the server. This information includes the project name, purpose, budget, and required documents.

[0130] Step 3:

[0131] The server uses natural language processing models to detect spelling errors

[0132] Input: JSON formatted approval document information received on the server

[0133] Output: Detected spelling and grammatical errors (correction suggestions)

[0134] The server passes the received JSON data to a natural language processing model (e.g., BERT or GPT-3), which detects typos (e.g., "new parts development" → "new product development") and grammatical errors in the sentence and returns correction suggestions.

[0135] Step 4:

[0136] User uploads a quote

[0137] Input: Digital quotation in PDF format

[0138] Output: Quote file saved on the device

[0139] The user uploads a quote (e.g., PDF format) to the device, which saves the quote and sends it to the server for further processing.

[0140] Step 5:

[0141] The device sends the estimate to the server

[0142] Input: Quote file uploaded by user

[0143] Output: Quote file sent to the server

[0144] The terminal sends the saved quotation file to the server.

[0145] Step 6:

[0146] The server uses OCR technology to extract the amount from the quote.

[0147] Input: Quotation file that arrived on the server

[0148] Output: Extracted amount data (e.g., "￥500,000")

[0149] The server uses OCR technology (e.g., Tesseract OCR) to extract the amount from the quote. For example, it extracts "￥500,000" as the amount in the quote.

[0150] Step 7:

[0151] The server compares the amount in the request form with the amount in the quotation

[0152] Input: Amount stated in the request and amount extracted from the estimate

[0153] Output: Amount match / mismatch detection result (correction suggestions if there are differences)

[0154] The server compares the extracted amount (e.g., "500,000 yen") with the amount stated in the approval request (e.g., "50,000 yen"), and if there is an error, generates a correction suggestion (e.g., "500,000 yen").

[0155] Step 8:

[0156] The server generates an error message

[0157] Input: Detected results of spelling errors, grammatical errors, and amount matches / mismatches

[0158] Output: Generated error message (e.g., "Typo detected: 'New parts development' → 'New product development'. Amount input error: '￥50,000' → '￥500,000'.")

[0159] The server generates error messages based on typos, grammar errors, and matched / mismatched amounts.

[0160] Step 9:

[0161] The server sends an error message to the terminal.

[0162] Input: The generated error message

[0163] Output: Error message sent to terminal

[0164] The server generates an error message and sends it to the terminal, allowing the user to review it and correct the contents of the request form.

[0165] Decision maker support system

[0166] Step 1:

[0167] The approver submits a new approval document to the server.

[0168] Input: The content of the new approval request entered by the approver into the terminal

[0169] Output: Approval information sent to the server

[0170] The decision maker enters a new request form on the terminal and sends it to the server.

[0171] Step 2:

[0172] The server searches the approval document database

[0173] Input: Contents of new approval request

[0174] Output: List of similar past approval documents found

[0175] The server searches a database of past approval requests using a natural language processing model (e.g., BERT or GPT-3) to extract approval requests with similar project names, budget amounts, and submitting departments.

[0176] Step 3:

[0177] The server obtains the approval result and displays it on the terminal.

[0178] Input: List of similar past approval documents

[0179] Output: Approval results of similar approval documents displayed on the terminal (e.g., 5 approval documents related to "new product development" were found, of which 2 were approved and 3 were rejected)

[0180] The server lists the search results and sends them to the approver's device along with past approval decisions. The approver makes a decision on the current approval decision, referring to the approval decisions of similar past approval decisions.

[0181] In this way, systems that support users and decision makers can streamline and improve the accuracy of the request document creation and approval process.

[0182] (Application example 1)

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

[0184] The traditional approval process required a lot of manual work, and there were frequent problems with typos and discrepancies in amounts. Searching for similar approval documents in the past was also inefficient, making it difficult to make quick decisions. While there is a particular need for more efficient approval process in factories, the lack of systems to automate current procedures has hindered improvements in efficiency and accuracy.

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

[0186] In this invention, the server includes: means for detecting typos and omissions, means for including a natural language processing model, means for including optical character recognition technology for extracting the amount stated in the request form from the estimate, means for comparing the amount stated in the request form with the amount extracted from the estimate, means for including a generative AI model for generating an error message based on the comparison result, means for generating a prompt sentence for presenting the error message to the user, means for scanning the request form and extracting text information, means for including a natural language processing model for searching past request form data, means for extracting similar request forms from the search results, and means for presenting the approval results of the extracted request form. This enables the efficiency and accuracy of the request form creation and approval process to be improved.

[0187] A "natural language processing model for detecting typos and misspellings" is an algorithm that automatically detects spelling and grammatical errors in a sentence and suggests corrections.

[0188] "Optical character recognition technology for extracting amounts from estimates" is a technology that extracts text information, particularly amounts, as digital data from images of estimates read by a scanner or camera.

[0189] A "generative AI model that generates error messages" is an artificial intelligence model that automatically generates error messages based on detected error information such as typos or mismatched amounts.

[0190] The "means for generating a prompt sentence" is a means for automatically generating an instruction sentence or a confirmation message to be presented to the user.

[0191] "Means of scanning approval documents and extracting text information" refers to technology for digitizing physical approval documents and obtaining text data from them.

[0192] The "natural language processing model for searching past approval request data" is an algorithm for analyzing a database of previously submitted approval requests and searching for and retrieving related information.

[0193] The "means for extracting similar approval documents" refers to a means for identifying and extracting approval documents whose contents are similar to the current approval document from a database of past approval documents.

[0194] The "means for presenting the decision results" is a means for obtaining the decision results of past approval requests and providing them to the user as information.

[0195] To implement this invention, a system is constructed that supports the process from receipt of approval documents to approval. Specifically, this system uses the following hardware and software:

[0196] Hardware:

[0197] Factory robot: Used for scanning approval documents and user interface

[0198] Scanner: Used to digitize physical documents and estimates

[0199] Server: processes and stores data

[0200] software:

[0201] OCR engine (Tesseract): Extracts text information from scanned documents

[0202] Natural language processing library (spaCy): used for text analysis, typo detection, and historical data search

[0203] Database (PostgreSQL): Store and search past approval documents

[0204] Program operation description:

[0205] 1. Scanning the approval document:

[0206] The terminal (factory robot) uses a scanner to read the approval document submitted by the user. The scanned image data is sent to the server, which then analyzes it with an OCR engine (Tesseract) and extracts the text data.

[0207] 2. Check for typos:

[0208] The extracted text data is analyzed on the server using a natural language processing library (spaCy). This analysis detects typos and omissions in the request form. The detection results are input into a generative AI model, which generates an error message along with suggested corrections.

[0209] 3. Amount Verification:

[0210] The amount written on the request form and the amount written on the quotation are extracted using OCR technology and automatically compared on the server. If they do not match, an error message is generated by the generative AI model.

[0211] 4. Searching historical data:

[0212] The server uses a natural language processing library to search a database of past approval documents (PostgreSQL) and extracts cases similar to the current approval document, allowing the approver to refer to past approval results.

[0213] 5. User Feedback:

[0214] Generated error messages and approval results for past approval requests are displayed as prompts on the terminal (factory robot) display so that the user can check them.

[0215] Examples:

[0216] For example, suppose a factory's A-Robot receives a new approval document, which is a "budget request for new product development." The robot first scans the document and extracts text information using an OCR engine. The server receives the text data and analyzes it using a natural language processing library (spaCy) to check for typos. The quotation is also scanned in the same way, and the amount is extracted. If the amount on the approval document and the quotation do not match, for example, if ¥500,000 is entered as ¥50,000, the generative AI model generates an error message.

[0217] Furthermore, the server searches for similar past requests for approval, and if, for example, there have been three similar "new product development" requests in the past, the approval results (e.g., two approved, one rejected) are displayed on the robot's screen.

[0218] Example prompt sentence:

[0219] The "New Product Development Budget Request" approval form has been scanned. Please check for typos and confirm that the amount is correct: 500,000 yen. Search for similar approval forms in the past and view the approval results.

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

[0221] Step 1:

[0222] When a user submits a request for approval, the terminal (factory robot) scans the request and sends the scanned image data to an OCR engine (Tesseract) to extract text information.

[0223] Input: Scanned image data of the approval document

[0224] Output: Extracted text data

[0225] Step 2:

[0226] The server receives the extracted text data and uses a natural language processing library (spaCy) to detect typos and omissions, and the detection results also include suggested corrections.

[0227] Input: Extracted text data

[0228] Output: Misspelling detection results (including correction suggestions)

[0229] Step 3:

[0230] The user also scans the quote using a scanner and sends the image data to the OCR engine, which extracts the quote amount.

[0231] Input: Scanned image data of quote

[0232] Output: Amount data extracted from the quotation

[0233] Step 4:

[0234] The server compares the amount data in the request and the quotation, and if the amounts do not match, the generative AI model automatically generates an error message.

[0235] Input: Amount data extracted from the approval document, amount data extracted from the quotation

[0236] Output: Error message

[0237] Step 5:

[0238] The server searches a database of past approval requests and uses a natural language processing library to extract requests similar to the current one.

[0239] Input: Text data of the approval request

[0240] Output: Similar past approval documents

[0241] Step 6:

[0242] The server generates a message showing the past approval results based on the extracted past approval request data. This message including the approval results is sent to the terminal (factory robot) and displayed to the user.

[0243] Input: Similar past approval documents data

[0244] Output: Past approval results and suggested messages

[0245] Step 7:

[0246] The user checks the error messages and past approval results displayed on the factory robot's display and makes corrections to the approval document as necessary.

[0247] Input: Error messages, past approval results

[0248] Output: Modified decision (if necessary)

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

[0250] This invention is a system for supporting approval process initiators and approvers, and improves the process more effectively by combining functions such as checking for typos, confirming amounts, and referencing past approval process data with an emotion engine that recognizes user emotions. This system utilizes AI technology, natural language processing (NLP), optical character recognition (OCR), and emotion recognition technology to provide an efficient and accurate approval process.

[0251] Proposer Support System

[0252] The user enters the details of the approval request into the terminal. This includes the project name, objectives, budget, and required documents. The terminal then sends this information to the server, where a natural language processing model is used to check for typos and grammatical errors. For example, if the user enters "new product development" and then erroneously enters "newly manufactured parts development," the AI ​​model detects this and generates correction suggestions. Furthermore, the content of the estimate attached to the approval request (e.g., "¥500,000") is extracted using OCR technology and compared with the amount entered in the approval request (e.g., "¥50,000"). If an error is found, the server generates an error message ("Typo detected: 'newly manufactured parts development' → 'new product development'. Amount input error: '¥50,000' → '¥500,000'") and sends it to the terminal. The user can then review the error message and correct the approval request.

[0253] Furthermore, the system has an emotion engine to recognize the user's emotions. The emotion engine collects and analyzes emotional data from facial expressions, voice, and text input patterns while the user is creating the request form. For example, if the user is feeling stressed, the system can recognize that emotion and adjust the way error messages are presented. Specifically, if the emotion engine determines that the user is feeling stressed, the system will display error messages in a gentle, supportive tone.

[0254] Decision maker support system

[0255] The decision maker enters the details of a newly received approval document into their terminal. This information is sent to the server, which searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. For example, if five approval documents related to "new product development" have been found in the past, the server obtains the approval results (two approved, three rejected) and displays them on the decision maker's terminal. This allows the decision maker to make quick and accurate decisions based on past examples.

[0256] Furthermore, the emotion engine recognizes the decision maker's emotional state and suggests a course of action if certain conditions are met. For example, if the emotion engine determines that a decision maker is feeling anxious or uncertain while reviewing past decision results, the system will highlight past success stories and suggest additional reference materials to support the decision maker's decision-making.

[0257] As a specific example, when a user creates a request for approval for a "new product development budget application," the system checks for typos and verifies that the amount matches the estimate. Furthermore, the system recognizes the user's emotions and displays a supportive error message if the user is feeling stressed. Furthermore, if the decision maker is feeling anxious, the system highlights specific success stories while referring to past approval results for similar applications. In this way, the present invention supports the entire process of request proposal and approval through emotion recognition, improving work efficiency and accuracy.

[0258] The processing flow will be explained below.

[0259] Proposer Support System

[0260] Program processing

[0261] Step 1:

[0262] The user enters the contents of the request form into the terminal.

[0263] The user enters information such as the project name, purpose, budget amount, and required documents into the approval form.

[0264] Step 2:

[0265] The terminal sends the entered approval request details to the server.

[0266] The terminal sends the request data to the server via the API using a POST request.

[0267] Step 3:

[0268] The server uses a natural language processing model to check the approval request for spelling and grammatical errors.

[0269] The server inputs the request text into a natural language processing (NLP) model to detect and point out typos and grammatical errors.

[0270] Step 4:

[0271] The server reads the contents of the quotation attached to the request form.

[0272] The server uses optical character recognition (OCR) technology to extract the amount from the quotation and compare it with the amount in the approval document.

[0273] Step 5:

[0274] The server compares the amount stated in the request with the amount extracted from the quotation.

[0275] The server compares the extracted amount information with the amount information on the request form to confirm that they match.

[0276] Step 6:

[0277] The server generates an error message based on the comparison.

[0278] If the server detects an error, it creates an error message and cleans up the contents.

[0279] Step 7:

[0280] Sends any server-generated error messages to the terminal for display to the user.

[0281] The server returns an error message in JSON format to the terminal, and the terminal displays the error message in the user interface (UI).

[0282] Step 8:

[0283] The user corrects the request according to the error message.

[0284] The user checks the error message displayed on the device, corrects the contents of the approval request, and sends the corrected version to the server again.

[0285] Step 9:

[0286] The emotion engine analyzes facial expressions and voice data as the user types.

[0287] The server uses an emotion engine to analyze the user's emotional state and processes the results.

[0288] Step 10:

[0289] The server adjusts how error messages are presented based on the emotion data.

[0290] The server takes appropriate considerations into account the user's emotional state and changes the tone of the error message.

[0291] ---

[0292] Decision maker support system

[0293] Program processing

[0294] Step 1:

[0295] The approver enters the contents of the newly received request into the terminal.

[0296] The approver enters the newly received approval information into the approval form. Example: Project name: "New product development" "Budget: ¥500,000"

[0297] Step 2:

[0298] The terminal sends the contents of the request to the server.

[0299] The terminal sends the request data to the server via the API using a POST request.

[0300] Step 3:

[0301] The server searches for similar requests from a database of past requests.

[0302] The server inputs the details of the request (project name, budget, purpose, etc.) into a natural language processing (NLP) model and searches the database.

[0303] Step 4:

[0304] The server extracts similar approval documents from the search results.

[0305] The server filters past requests based on attributes such as amount, project content, and submitting department, and lists the most matching data.

[0306] Step 5:

[0307] The server obtains the approval results of the extracted past approval documents.

[0308] The server obtains the decision results (approval, rejection, etc.) of the extracted proposals and organizes them along with any error messages.

[0309] Step 6:

[0310] The server sends the approval status of past approval requests to the terminal and presents it to the approver.

[0311] The server returns the approval status in JSON format to the terminal, and the terminal displays the information on the UI.

[0312] Step 7:

[0313] The emotion engine analyzes the emotional state of the decision maker.

[0314] The server uses an emotion engine to analyze the decision maker's emotional state and processes the results.

[0315] Step 8:

[0316] The server proposes a response policy based on the emotion data.

[0317] The server suggests the most appropriate action depending on the decision maker's emotional state, for example by displaying information that emphasizes past success stories.

[0318] ---

[0319] These processing steps provide efficient and accurate support to both the request initiator and the approver. By incorporating an emotion engine, more natural interactions can be achieved that take into consideration the user's emotions, further improving the efficiency and accuracy of work.

[0320] Example 2

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

[0322] The current approval process requires a lot of manual work, which is time-consuming and labor-intensive. It's also prone to typos and input errors, which can delay approval. Furthermore, there's a lack of support that takes into account the feelings of users and decision makers, which can lead to increased stress and anxiety. This creates a need for greater efficiency and accuracy in the process.

[0323] 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 a means including a natural language processing model for detecting typographical errors, a means for extracting numerical information described in the approval request form from the document, and a means for comparing the numerical information described in the approval request form with the numerical information extracted from the document. This makes it possible to automatically detect typographical errors and discrepancies in amounts, thereby reducing the manual work of the user.

[0324] Furthermore, in this invention, the server includes means for generating an error message based on the comparison result, means for presenting the error message to the user, and means including an emotion recognition engine for recognizing the user's emotion and adjusting the way the error message is presented, thereby enabling appropriate support for the user and enabling them to check and correct the error message while reducing stress.

[0325] The server also includes a means including a natural language processing model for searching past approval request data, a means for extracting similar approval requests from the search results, a means for presenting the decision results of the extracted approval requests, and a means including an emotion recognition engine for recognizing the emotions of the decision maker and making suggestions to support the decision-making. This allows the decision maker to make decisions quickly and accurately based on past cases and receive appropriate support.

[0326] A "natural language processing model for detecting typos" is an artificial intelligence technique used to analyze text data and automatically detect typos, spelling errors, and grammatical errors.

[0327] "Means for extracting numerical information contained in a request form from the document" refers to a technology for accurately extracting numerical information such as amounts from attached documents (such as estimates).

[0328] "Means for comparing the numerical information entered in the request form with the numerical information extracted from the document" refers to a technology for comparing the numerical information entered in the request form with the numerical information extracted from the document and checking for matches or mismatches.

[0329] The "means for generating an error message" is a technique for creating a message to notify the user when a typographical error or a mismatch in numerical information is detected.

[0330] "Means for presenting an error message to the user" refers to a technique for displaying the generated error message on the user's terminal screen and prompting the user to correct the error.

[0331] An "emotion recognition engine" is a technology that analyzes the facial expressions, voice, and text input patterns of users and decision makers to recognize emotions such as stress and anxiety.

[0332] "Means for recognizing emotions and adjusting the presentation method of error messages" refers to a technology that adjusts the display method and tone of error messages based on the user's emotional state recognized by an emotion recognition engine.

[0333] The "natural language processing model for searching past approval documents" is an artificial intelligence technology used to search a database of past approval documents and identify similar approval documents.

[0334] "Means for extracting similar approval documents" refers to a technique for selecting approval documents with similar content from past approval documents.

[0335] The "means for presenting the decision results of the extracted request documents" is a technology for displaying the decision results (such as approval or rejection) of the extracted past request documents to the user or authorizer.

[0336] The "emotion recognition engine that makes suggestions to support decision-making" is a technology that recognizes the emotional state of the decision maker and supports the decision-making process by presenting past success stories and additional materials.

[0337] This invention is a system for supporting approval request drafters and approvers, and improves the process more effectively by combining functions for checking for typos, confirming amounts, and referencing past approval request data with an emotion recognition engine that recognizes the user's emotions. This system utilizes AI technology, natural language processing (NLP), optical character recognition (OCR), and emotion recognition technology to provide an efficient and accurate approval request process.

[0338] System Configuration

[0339] Proposer Support System

[0340] The user enters the details of the approval request into the terminal. This includes the project name, purpose, budget, and required documents. The terminal sends this information to the server, which uses a natural language processing model to check for typos and grammatical errors. For example, if the user enters "new product development" and then misspells "new parts development," the server will detect this and generate correction suggestions.

[0341] Next, the content of the quotation attached to the request form (for example, "¥500,000") is extracted using OCR technology and compared with the amount entered in the request form (for example, "¥50,000"). If there is an error, the server generates an error message and sends it to the terminal, stating, "Typo detected: 'New parts development' → 'New product development'. Amount input error: '¥50,000' → '¥500,000'." The user can then check the error message and correct the request form.

[0342] Additionally, the system is equipped with an emotion recognition engine. The emotion recognition engine collects and analyzes emotional data from facial expressions, voice, and text input patterns while the user is creating the request form. For example, if the user is feeling stressed, the system recognizes that emotion and adjusts the way error messages are presented. Specifically, if the emotion recognition engine determines that the user is feeling stressed, the system displays error messages in a gentle, supportive tone.

[0343] Decision maker support system

[0344] The decision maker enters the details of a newly received approval document into their terminal. This information is sent to the server, which searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. For example, if five approval documents related to "new product development" have been found in the past, the server obtains the approval results (two approved, three rejected) and displays them on the decision maker's terminal. This allows the decision maker to make quick and accurate decisions based on past examples.

[0345] Furthermore, the emotion recognition engine recognizes the decision maker's emotional state and suggests a course of action if certain conditions are met. For example, if the emotion recognition engine determines that the decision maker is feeling anxious or uncertain while reviewing past decision results, the system will highlight past success stories and suggest providing additional reference materials.

[0346] Examples and prompts

[0347] Specific examples

[0348] 1. Check for spelling errors in your input

[0349] A user creates a request for approval for a "new product development budget" and mistakenly types "new part development." The server detects this and suggests correcting it to "new product development."

[0350] 2. Check the amount

[0351] If a user enters "¥50,000" in a request form and the attached estimate states "¥500,000," the server will detect this discrepancy and prompt the user to change "¥50,000" to "¥500,000."

[0352] 3. Emotion-based error message display

[0353] If the user is stressed, an emotion recognition engine will detect this and display a gentle error message.

[0354] 4. Reference to past approval documents

[0355] When a decision maker approves a "new product development budget request," they search a database of past approval requests and report that two similar requests have been approved and three have been rejected.

[0356] Prompt Sentence Examples

[0357] 1. "Please check the new product development approval documents for typos and inconsistencies in amounts."

[0358] 2. "Please display error messages in a gentle tone if the user is feeling stressed while creating a request."

[0359] 3. "Search for similar past approval requests and their approval results and display a list."

[0360] 4. "If the decision maker is feeling unsure, highlight past success stories."

[0361] In this way, the system improves the efficiency of the approval process and provides user support through specific implementation examples and prompt statements.

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

[0363] Step 1:

[0364] The user inputs the details of the approval request into the terminal. The input details include the project name, purpose, budget amount, required documents, etc. For example, the user inputs the project name "New product development," the purpose "To improve sales," the budget amount "500,000 yen," and uploads the quotation file. This input information becomes the basic data for the next step.

[0365] Step 2:

[0366] The terminal sends the entered information to the server. Data such as the project name, purpose, budget amount, and attached estimate are transferred to the server via the network. After the server receives this information, it prepares it for the next process.

[0367] Step 3:

[0368] The server uses a natural language processing model to check for typos and grammatical errors. The server inputs the received text data into a natural language processing (NLP) model to detect typos and grammatical errors. For example, if "new parts development" is input incorrectly, the server generates a suggestion to correct this to "new product development." This suggestion is sent to the next step.

[0369] Step 4:

[0370] The server uses OCR technology to extract the amount from the quote and compare it with the amount in the approval request. The server inputs the attached quote file into the OCR module and obtains the extracted amount (e.g., "500,000 yen"). This is then compared with the amount entered in the approval request (e.g., "50,000 yen") to confirm any discrepancies. The result of this comparison becomes the data to proceed to the next step.

[0371] Step 5:

[0372] The server generates an error message and sends it to the terminal. The server generates an error message based on the results of the typo detection and the discrepancy in the amount. For example, an error message such as "Typo detected: 'New parts development' → 'New product development'. Amount input error: '￥50,000' → '￥500,000'" is generated and sent to the terminal. The user confirms this error message.

[0373] Step 6:

[0374] The user checks the error message and corrects the approval request. The user checks the error message on the terminal and makes the necessary corrections. For example, the project name is changed to "New Product Development" and the budget amount is changed to "500,000 yen." This corrected information is sent back to the server and proceeds to the next process.

[0375] Step 7:

[0376] The emotion recognition engine recognizes the user's emotions and generates an appropriate error message. The server uses the emotion recognition engine to collect and analyze emotional data from the user's facial expressions, voice, and text input patterns. For example, if the user is feeling stressed, the system will recognize this and display an error message in a gentle tone. For example, it will display, "Thank you for your hard work. We understand that you are probably feeling stressed, but we have corrected the typo in 'New Parts Development' to 'New Product Development'. You're almost there, keep trying!"

[0377] (Application example 2)

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

[0379] Conventional approval systems lack sufficient means for detecting typos and confirming amounts, and do not provide error messages or decision-making support that take into account the emotional state of the user or approver. Therefore, there is a need to improve the efficiency and accuracy of the approval process. In particular, there is a need for a method to reduce unnecessary rework caused by typos and incorrect amounts, as well as user stress. Furthermore, in factory operations, there is a need to streamline the process of reviewing numerous work instructions and maintenance requests.

[0380] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means including a natural language processing model for detecting typographical errors, means for extracting the amount stated in the request form from the estimate, means for comparing the amount stated in the request form with the amount extracted from the estimate, means including an emotion recognition engine for recognizing the user's emotional state, means for adjusting an error message based on the results of the emotion recognition engine, means for presenting the error message to the user, means including a natural language processing model for searching past request form data, means for extracting similar request forms from the search results, means for presenting the approval result of the extracted request form, means including an emotion recognition engine for recognizing the emotional state of the approver, and means for providing additional reference materials based on the results of the emotion recognition engine. This enables efficient detection and correction of typographical errors and incorrect amounts, and enables appropriate feedback and decision-making support that takes into account the emotional state of the user and the approver.

[0381] "Typographical errors" refers to spelling or typing errors contained in a document.

[0382] "Natural language processing model" refers to a machine learning or AI algorithm designed to understand, generate, or translate natural language.

[0383] "Monetary value extraction" refers to the process of identifying and extracting numerical information contained within a document.

[0384] An "emotion recognition engine" refers to technology that collects and analyzes emotional data from a user's facial expressions, voice, and text input patterns.

[0385] "Error Message" means a message that notifies the user about a problem or error detected by the system.

[0386] "Search Results" means the results obtained from a database or source through a search process.

[0387] "Emotional state" refers to a user's emotional state at a particular point in time.

[0388] "Similar approval documents" refers to past approval document data that has similar content to the current approval document.

[0389] "Decision result" refers to the final approval or rejection of the request.

[0390] "Feedback" refers to the reaction or information that a system provides to a user.

[0391] "Decision support" refers to processes or systems that provide information and tools to help users or decision makers make the best decisions.

[0392] This invention is a system for supporting approval process initiators and approvers, and it improves the process more effectively by combining functions such as checking for typos, confirming amounts, and referencing past approval process data with an emotion engine that recognizes user emotions. This system utilizes AI technology, natural language processing (NLP), optical character recognition (OCR), and emotion recognition technology to provide an efficient and accurate approval process.

[0393] Proposer Support System

[0394] When the drafter enters the contents of the request form into the terminal, a natural language processing model is used to detect typos. The terminal then sends this information to the server, which uses the natural language processing model to check the document for typos and grammatical errors. Additionally, OCR technology is used to extract the amount from the estimate attached to the request form and compare it with the amount entered in the request form. If there is an error, the server generates an error message and sends it to the terminal, allowing the user to review the error message and correct the request form.

[0395] Decision maker support system

[0396] The decision maker enters the details of a newly received approval document into a terminal. This information is sent to a server, which then searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. This allows the decision maker to make decisions quickly and accurately based on past examples.

[0397] Emotion Recognition Engine

[0398] The emotion recognition engine collects and analyzes emotional data from facial expressions, voice, and text input patterns while a user is creating a request for approval. For example, if a user is feeling stressed, the system can recognize that emotion and adjust the way error messages are presented. Additionally, if the emotion recognition engine determines that a decision maker is feeling anxious or uncertain while reviewing past approval results, the system can highlight past success stories and suggest additional reference materials to support the decision maker's decision-making.

[0399] Specific hardware and software

[0400] To implement this system, the following hardware and software are required:

[0401] Hardware: User devices (smartphones, tablets, PCs, etc.), servers, cameras for optical character recognition.

[0402] Software: Natural language processing models (Spacy), optical character recognition software (pytesseract), emotion recognition engines (transformers).

[0403] Examples of concrete examples and prompts

[0404] As an example of a valid use case, consider a factory maintenance request. Here is an example prompt:

[0405] Specific examples

[0406] Input: Image file "maintenance_request.jpg"

[0407] Output: Extracted text: "I would like to request maintenance for Machine A. The budget is 100,000 yen." Suggested correction for typos: "Request -> Check required." Emotion recognition result: "Emotion: Negative, Confidence: 0.85."

[0408] Prompt Sentence Examples

[0409] Extract the text from the image file "maintenance_request.jpg" and check for typos and user sentiment. Also, display the approval results from similar requests in the past.

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

[0411] Step 1:

[0412] The user inputs the details of the approval request into the terminal. The input data includes the project name, purpose, budget amount, required documents, etc. This input data is sent from the terminal to the server.

[0413] Step 2:

[0414] The server checks the received request for typos and grammatical errors using a natural language processing model (Spacy). The input is the text data of the request, and the output is correction suggestions and error messages. The server detects typos and grammatical errors and generates appropriate correction suggestions.

[0415] Step 3:

[0416] Next, the server processes the image of the quotation attached to the request form using optical character recognition software (pytesseract) to extract the amount. The input is the image data of the quotation, and the output is the extracted amount data. The server obtains the amount information as text and compares it with the amount written on the request form.

[0417] Step 4:

[0418] The server compares the amount written in the request form with the amount extracted from the quotation, and generates an error message if there is a discrepancy. The input is the amount data in the request form and the extracted amount data, and the output is an error message. The server detects errors and generates a specific error message.

[0419] Step 5:

[0420] The server uses emotion recognition engines (transformers) to analyze the user's emotional state. The input is facial expression, voice, and text input data while the user is creating the request, and the output is the emotion recognition results. The server evaluates the user's emotional state and recognizes negative emotions such as stress.

[0421] Step 6:

[0422] The server adjusts the presentation of error messages based on the results of the emotion recognition engine. The input is the emotion recognition result, and the output is the adjusted error message. If the user is feeling stressed, the server presents the error message in a gentle, supportive tone.

[0423] Step 7:

[0424] The user checks the error message and corrects any necessary corrections. The input is the error message sent from the server, and the output is the corrected approval request data. The user corrects the approval request based on the error message.

[0425] Step 8:

[0426] The approver inputs the details of a newly received approval document into the terminal. This is sent to the server, which searches a database of past approval documents. The input is the data of the new approval document, and the output is a list of similar past approval documents. The server uses a natural language processing model to search the database and extract similar approval documents.

[0427] Step 9:

[0428] The server presents the approver with a list of similar approval documents from the search results and displays the approval results for each approval document. The input is a list of similar past approval documents, and the output is the display data of the approval results. The server helps the approver make decisions quickly and accurately based on past cases.

[0429] Step 10:

[0430] The emotion recognition engine recognizes the decision maker's emotional state and proposes a course of action if certain conditions are met. The input is the decision maker's facial expression, voice, and text data, and the output is the emotion recognition results and proposal data. If the decision maker has concerns or doubts, the server highlights past success stories and provides additional reference materials.

[0431] Specific actions

[0432] Specific examples

[0433] Input: Image file "maintenance_request.jpg"

[0434] Output: Extracted text: "I would like to request maintenance for Machine A. The budget is 100,000 yen." Suggested correction for typos: "Request -> Check required." Emotion recognition result: "Emotion: Negative, Confidence: 0.85."

[0435] Prompt Sentence Examples

[0436] Extract the text from the image file "maintenance_request.jpg" and check for typos and user sentiment. Also, display the approval results from similar requests in the past.

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

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

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

[0440] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0453] This invention is a system to support the drafter and approver of approval requests, and mainly provides functions for checking for typos, confirming amounts, and referencing past approval request data. This system utilizes AI technology, natural language processing (NLP) and optical character recognition (OCR) technologies to provide an efficient and accurate approval process.

[0454] Proposer Support System

[0455] The user enters the details of the approval request into the terminal. This includes the project name, objectives, budget, and required documents. The terminal then sends this information to the server, where a natural language processing model is used to check for typos and grammatical errors. For example, if the user enters "new product development" but misspells "new parts development," the AI ​​model detects this and generates correction suggestions. Furthermore, the content of the estimate attached to the approval request (e.g., "¥500,000") is extracted using OCR technology and compared with the amount entered in the approval request (e.g., "¥50,000"). If an error is found, the server generates an error message ("Typo detected: 'New parts development' → 'New product development'. Amount input error: '¥50,000' → '¥500,000'") and sends it to the terminal. The user can then review the error message and correct the approval request.

[0456] Decision maker support system

[0457] The decision maker enters the details of a newly received approval document into their terminal. This information is sent to the server, which searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. For example, if five approval documents related to "new product development" have been found in the past, the server obtains the approval results (two approved, three rejected) and displays them on the decision maker's terminal. This allows the decision maker to make quick and accurate decisions based on past examples.

[0458] As a specific example, when a user creates a request for approval for a "new product development budget application," the system checks for typos and omissions and confirms that the amount matches the estimate. The system also allows the approver to refer to the approval results of similar requests in the past, making the process more efficient. In this way, the present invention supports the approval process, improving work efficiency and accuracy.

[0459] The processing flow will be explained below.

[0460] Proposer Support System

[0461] Program processing

[0462] Step 1:

[0463] The user enters the contents of the request form into the terminal.

[0464] The user enters information such as the project name, purpose, budget amount, and required documents into the approval form.

[0465] Step 2:

[0466] The terminal sends the entered approval request details to the server.

[0467] The terminal sends the request data to the server via the API using a POST request.

[0468] Step 3:

[0469] The server uses a natural language processing model to check the approval request for spelling and grammatical errors.

[0470] The server inputs the request text into a natural language processing (NLP) model to detect and point out typos and grammatical errors.

[0471] Step 4:

[0472] The server reads the contents of the quotation attached to the request form.

[0473] The server uses optical character recognition (OCR) technology to extract the amount from the quotation and compare it with the amount in the approval document.

[0474] Step 5:

[0475] The server compares the amount stated in the request with the amount extracted from the quotation.

[0476] The server compares the extracted amount information with the amount information on the request form to confirm that they match.

[0477] Step 6:

[0478] The server generates an error message based on the comparison.

[0479] If the server detects an error, it creates an error message and cleans up the contents.

[0480] Step 7:

[0481] Sends any server-generated error messages to the terminal for display to the user.

[0482] The server returns an error message in JSON format to the terminal, and the terminal displays the error message in the user interface (UI).

[0483] Step 8:

[0484] The user corrects the request according to the error message.

[0485] The user checks the error message displayed on the device, corrects the contents of the approval request, and sends the corrected version to the server again.

[0486] ---

[0487] Decision maker support system

[0488] Program processing

[0489] Step 1:

[0490] The approver enters the contents of the newly received request into the terminal.

[0491] The approver enters the newly received approval information into the approval form. Example: Project name: "New product development" "Budget: ¥500,000"

[0492] Step 2:

[0493] The terminal sends the contents of the request to the server.

[0494] The terminal sends the request data to the server via the API using a POST request.

[0495] Step 3:

[0496] The server searches for similar requests from a database of past requests.

[0497] The server inputs the details of the request (project name, budget, purpose, etc.) into a natural language processing (NLP) model and searches the database.

[0498] Step 4:

[0499] The server extracts similar approval documents from the search results.

[0500] The server filters past requests based on attributes such as amount, project content, and submitting department, and lists the most matching data.

[0501] Step 5:

[0502] The server obtains the approval results of the extracted past approval documents.

[0503] The server obtains the decision results (approval, rejection, etc.) of the extracted proposals and organizes them along with any error messages.

[0504] Step 6:

[0505] The server sends the approval status of past approval requests to the terminal and presents it to the approver.

[0506] The server returns the approval status in JSON format to the terminal, and the terminal displays the information on the UI.

[0507] Example 1

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

[0509] In the conventional approval process, the proposer had to manually check the approval document for typos and grammatical errors, and also manually check for discrepancies between the amount listed on the estimate and the amount listed on the approval document. This made it prone to errors and increased the likelihood of delays in the approval process. Furthermore, the approver had to manually search past approval document data and refer to the approval results of similar approval documents, making it difficult to make efficient decisions. A solution to these problems was needed.

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

[0511] In this invention, the server includes: a means for a user to input the contents of a request form into a terminal and the terminal transmits this information to the server; a means including a natural language processing model for detecting typographical errors; optical character recognition means for extracting the amount stated in the request form from an estimate; means for comparing the amount stated in the request form with the amount extracted from the estimate; means for generating an error message based on the comparison result; and means for presenting the error message to the user. This allows the drafter to automatically detect and correct typographical errors and discrepancies in the amount in the request form, thereby realizing an efficient and error-free request process. The server also includes a means including a natural language processing model for searching past request form data; means for extracting similar request forms from the search results; and means for presenting the approval results of the extracted request forms. This allows the decision maker to quickly refer to data on similar past request forms and make decisions efficiently.

[0512] A "user" is someone who inputs the contents of a request form and checks error messages from the system.

[0513] A "terminal" is an electronic device that a user uses to input the contents of a request form and exchange information with a server.

[0514] A "server" is a central processing unit that receives information sent by a user, processes it, and returns the results to the terminal.

[0515] A "requisition form" is a document that lists the project name, purpose, budget amount, and required documents, and is used for approval procedures within a company.

[0516] A "natural language processing model" is a machine learning model that analyzes text data to detect typos and grammatical errors.

[0517] "Typographical errors" refer to typos or input errors contained in the text content of a request form.

[0518] "Optical character recognition" is a technology that extracts character information from images or documents such as PDF files.

[0519] An "quote" is a document that lists the budget amount and detailed expenses, and is attached to a request form.

[0520] The "comparison method" is a method for comparing the amount stated in the request form with the amount extracted from the estimate to determine whether they match or not.

[0521] An "error message" is information that notifies the user of problems with the request form, such as typos or mismatched amounts.

[0522] The "search method" is a technology for searching past approval request data from a database.

[0523] A "similar request form" is a past request form whose content is similar to that of the current request form.

[0524] "Decision result" refers to the result of approval or rejection of a past request for approval.

[0525] This invention is a system to support the drafter and approver of approval requests, primarily by checking for typos, confirming amounts, and providing functions for referencing past approval request data. The system utilizes AI technology, natural language processing (NLP) and optical character recognition (OCR) technologies, to provide an efficient and accurate approval process.

[0526] First, the user inputs the details of the request into the device. This information includes the project name, purpose, budget, and required documents. The device then sends this information to the server, which uses a natural language processing model (e.g., BERT or GPT-3) to check for typos and grammatical errors.

[0527] For example, if a user accidentally types "new product development" instead of "new parts development," the AI ​​model detects the error and generates the correct spelling, "new product development," as a correction suggestion. Also, when a user uploads a quote (e.g., a PDF file) attached to a request form to their device, the quote is sent from the device to the server. The server uses OCR technology (e.g., Tesseract OCR) to extract the amount information from the quote. The server compares the extracted amount (e.g., "¥500,000") with the amount written in the request form (e.g., "¥50,000") and generates a correction suggestion if there is an error.

[0528] The server compiles these correction suggestions and generates an error message (e.g., "Typo detected: 'New parts development' → 'New product development'. Amount input error: '￥50,000' → '￥500,000'.") and sends it to the terminal. The user can check the error message and correct the approval request.

[0529] Next, the approver enters the details of the newly received approval document into their terminal and sends it to the server. The server uses a natural language processing model to search a database of past approval documents, searching for past approval documents with similar amounts, project details, and submitting departments. For example, if five past approval documents related to "new product development" are found, the server obtains the approval results (two approved, three rejected) and displays them on the approver's terminal. This enables the approver to make quick and accurate decisions based on past examples.

[0530] An example of a specific prompt is:

[0531] 1. Typo detection: "Detect typos in this text: New parts development"

[0532] 2. OCR processing of quote: "Please extract the amount from this PDF file"

[0533] 3. Search for similar approval documents: "Search for past approval documents similar to the following: Project name = New product development, Budget = ¥500,000"

[0534] This system allows users and decision makers to work efficiently and accurately during the approval process, minimizing errors.

[0535] In this way, the present invention is a system that supports the process of drafting and approving requests, and aims to improve the efficiency and accuracy of business operations.

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

[0537] Proposer Support System

[0538] Step 1:

[0539] The user enters the details of the approval request.

[0540] Input: Project name, purpose, budget amount, required documents, and other information on the approval request

[0541] Output: Input information is saved to the terminal

[0542] The user enters the project name (e.g., "New product development"), purpose (e.g., "Market expansion"), budget amount (e.g., "500,000 yen"), and required documents (e.g., "Quote") into a form on the device. The device converts the input data into JSON format and sends it to the server.

[0543] Step 2:

[0544] The device sends the input information to the server

[0545] Input: Approval information entered by the user on the device (JSON format)

[0546] Output: Approval information sent to the server

[0547] The device converts the user's input into JSON format and sends it to the server. This information includes the project name, purpose, budget, and required documents.

[0548] Step 3:

[0549] The server uses natural language processing models to detect spelling errors

[0550] Input: JSON formatted approval document information received on the server

[0551] Output: Detected spelling and grammatical errors (correction suggestions)

[0552] The server passes the received JSON data to a natural language processing model (e.g., BERT or GPT-3), which detects typos (e.g., "new parts development" → "new product development") and grammatical errors in the sentence and returns correction suggestions.

[0553] Step 4:

[0554] User uploads a quote

[0555] Input: Digital quotation in PDF format

[0556] Output: Quote file saved on the device

[0557] The user uploads a quote (e.g., PDF format) to the device, which saves the quote and sends it to the server for further processing.

[0558] Step 5:

[0559] The device sends the estimate to the server

[0560] Input: Quote file uploaded by user

[0561] Output: Quote file sent to the server

[0562] The terminal sends the saved quotation file to the server.

[0563] Step 6:

[0564] The server uses OCR technology to extract the amount from the quote.

[0565] Input: Quotation file that arrived on the server

[0566] Output: Extracted amount data (e.g., "￥500,000")

[0567] The server uses OCR technology (e.g., Tesseract OCR) to extract the amount from the quote. For example, it extracts "￥500,000" as the amount in the quote.

[0568] Step 7:

[0569] The server compares the amount in the request form with the amount in the quotation

[0570] Input: Amount stated in the request and amount extracted from the estimate

[0571] Output: Amount match / mismatch detection result (correction suggestions if there are differences)

[0572] The server compares the extracted amount (e.g., "500,000 yen") with the amount stated in the approval request (e.g., "50,000 yen"), and if there is an error, generates a correction suggestion (e.g., "500,000 yen").

[0573] Step 8:

[0574] The server generates an error message

[0575] Input: Detected results of spelling errors, grammatical errors, and amount matches / mismatches

[0576] Output: Generated error message (e.g., "Typo detected: 'New parts development' → 'New product development'. Amount input error: '￥50,000' → '￥500,000'.")

[0577] The server generates error messages based on typos, grammar errors, and matched / mismatched amounts.

[0578] Step 9:

[0579] The server sends an error message to the terminal.

[0580] Input: The generated error message

[0581] Output: Error message sent to terminal

[0582] The server generates an error message and sends it to the terminal, allowing the user to review it and correct the contents of the request form.

[0583] Decision maker support system

[0584] Step 1:

[0585] The approver submits a new approval document to the server.

[0586] Input: The content of the new approval request entered by the approver into the terminal

[0587] Output: Approval information sent to the server

[0588] The decision maker enters a new request form on the terminal and sends it to the server.

[0589] Step 2:

[0590] The server searches the approval document database

[0591] Input: Contents of new approval request

[0592] Output: List of similar past approval documents found

[0593] The server searches a database of past approval requests using a natural language processing model (e.g., BERT or GPT-3) to extract approval requests with similar project names, budget amounts, and submitting departments.

[0594] Step 3:

[0595] The server obtains the approval result and displays it on the terminal.

[0596] Input: List of similar past approval documents

[0597] Output: Approval results of similar approval documents displayed on the terminal (e.g., 5 approval documents related to "new product development" were found, of which 2 were approved and 3 were rejected)

[0598] The server lists the search results and sends them to the approver's device along with past approval decisions. The approver makes a decision on the current approval decision, referring to the approval decisions of similar past approval decisions.

[0599] In this way, systems that support users and decision makers can streamline and improve the accuracy of the request document creation and approval process.

[0600] (Application example 1)

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

[0602] The traditional approval process required a lot of manual work, and there were frequent problems with typos and discrepancies in amounts. Searching for similar approval documents in the past was also inefficient, making it difficult to make quick decisions. While there is a particular need for more efficient approval process in factories, the lack of systems to automate current procedures has hindered improvements in efficiency and accuracy.

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

[0604] In this invention, the server includes: means for detecting typos and omissions, means for including a natural language processing model, means for including optical character recognition technology for extracting the amount stated in the request form from the estimate, means for comparing the amount stated in the request form with the amount extracted from the estimate, means for including a generative AI model for generating an error message based on the comparison result, means for generating a prompt sentence for presenting the error message to the user, means for scanning the request form and extracting text information, means for including a natural language processing model for searching past request form data, means for extracting similar request forms from the search results, and means for presenting the approval results of the extracted request form. This enables the efficiency and accuracy of the request form creation and approval process to be improved.

[0605] A "natural language processing model for detecting typos and misspellings" is an algorithm that automatically detects spelling and grammatical errors in a sentence and suggests corrections.

[0606] "Optical character recognition technology for extracting amounts from estimates" is a technology that extracts text information, particularly amounts, as digital data from images of estimates read by a scanner or camera.

[0607] A "generative AI model that generates error messages" is an artificial intelligence model that automatically generates error messages based on detected error information such as typos or mismatched amounts.

[0608] The "means for generating a prompt sentence" is a means for automatically generating an instruction sentence or a confirmation message to be presented to the user.

[0609] "Means of scanning approval documents and extracting text information" refers to technology for digitizing physical approval documents and obtaining text data from them.

[0610] The "natural language processing model for searching past approval request data" is an algorithm for analyzing a database of previously submitted approval requests and searching for and retrieving related information.

[0611] The "means for extracting similar approval documents" refers to a means for identifying and extracting approval documents whose contents are similar to the current approval document from a database of past approval documents.

[0612] The "means for presenting the decision results" is a means for obtaining the decision results of past approval requests and providing them to the user as information.

[0613] To implement this invention, a system is constructed that supports the process from receipt of approval documents to approval. Specifically, this system uses the following hardware and software:

[0614] Hardware:

[0615] Factory robot: Used for scanning approval documents and user interface

[0616] Scanner: Used to digitize physical documents and estimates

[0617] Server: processes and stores data

[0618] software:

[0619] OCR engine (Tesseract): Extracts text information from scanned documents

[0620] Natural language processing library (spaCy): used for text analysis, typo detection, and historical data search

[0621] Database (PostgreSQL): Store and search past approval documents

[0622] Program operation description:

[0623] 1. Scanning the approval document:

[0624] The terminal (factory robot) uses a scanner to read the approval document submitted by the user. The scanned image data is sent to the server, which then analyzes it with an OCR engine (Tesseract) and extracts the text data.

[0625] 2. Check for typos:

[0626] The extracted text data is analyzed on the server using a natural language processing library (spaCy). This analysis detects typos and omissions in the request form. The detection results are input into a generative AI model, which generates an error message along with suggested corrections.

[0627] 3. Amount Verification:

[0628] The amount written on the request form and the amount written on the quotation are extracted using OCR technology and automatically compared on the server. If they do not match, an error message is generated by the generative AI model.

[0629] 4. Searching historical data:

[0630] The server uses a natural language processing library to search a database of past approval documents (PostgreSQL) and extracts cases similar to the current approval document, allowing the approver to refer to past approval results.

[0631] 5. User Feedback:

[0632] Generated error messages and approval results for past approval requests are displayed as prompts on the terminal (factory robot) display so that the user can check them.

[0633] Examples:

[0634] For example, suppose a factory's A-Robot receives a new approval document, which is a "budget request for new product development." The robot first scans the document and extracts text information using an OCR engine. The server receives the text data and analyzes it using a natural language processing library (spaCy) to check for typos. The quotation is also scanned in the same way, and the amount is extracted. If the amount on the approval document and the quotation do not match, for example, if ¥500,000 is entered as ¥50,000, the generative AI model generates an error message.

[0635] Furthermore, the server searches for similar past requests for approval, and if, for example, there have been three similar "new product development" requests in the past, the approval results (e.g., two approved, one rejected) are displayed on the robot's screen.

[0636] Example prompt sentence:

[0637] The "New Product Development Budget Request" approval form has been scanned. Please check for typos and confirm that the amount is correct: 500,000 yen. Search for similar approval forms in the past and view the approval results.

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

[0639] Step 1:

[0640] When a user submits a request for approval, the terminal (factory robot) scans the request and sends the scanned image data to an OCR engine (Tesseract) to extract text information.

[0641] Input: Scanned image data of the approval document

[0642] Output: Extracted text data

[0643] Step 2:

[0644] The server receives the extracted text data and uses a natural language processing library (spaCy) to detect typos and omissions, and the detection results also include suggested corrections.

[0645] Input: Extracted text data

[0646] Output: Misspelling detection results (including correction suggestions)

[0647] Step 3:

[0648] The user also scans the quote using a scanner and sends the image data to the OCR engine, which extracts the quote amount.

[0649] Input: Scanned image data of quote

[0650] Output: Amount data extracted from the quotation

[0651] Step 4:

[0652] The server compares the amount data in the request and the quotation, and if the amounts do not match, the generative AI model automatically generates an error message.

[0653] Input: Amount data extracted from the approval document, amount data extracted from the quotation

[0654] Output: Error message

[0655] Step 5:

[0656] The server searches a database of past approval requests and uses a natural language processing library to extract requests similar to the current one.

[0657] Input: Text data of the approval request

[0658] Output: Similar past approval documents

[0659] Step 6:

[0660] The server generates a message showing the past approval results based on the extracted past approval request data. This message including the approval results is sent to the terminal (factory robot) and displayed to the user.

[0661] Input: Similar past approval documents data

[0662] Output: Past approval results and suggested messages

[0663] Step 7:

[0664] The user checks the error messages and past approval results displayed on the factory robot's display and makes corrections to the approval document as necessary.

[0665] Input: Error messages, past approval results

[0666] Output: Modified decision (if necessary)

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

[0668] This invention is a system for supporting approval process initiators and approvers, and improves the process more effectively by combining functions such as checking for typos, confirming amounts, and referencing past approval process data with an emotion engine that recognizes user emotions. This system utilizes AI technology, natural language processing (NLP), optical character recognition (OCR), and emotion recognition technology to provide an efficient and accurate approval process.

[0669] Proposer Support System

[0670] The user enters the details of the approval request into the terminal. This includes the project name, objectives, budget, and required documents. The terminal then sends this information to the server, where a natural language processing model is used to check for typos and grammatical errors. For example, if the user enters "new product development" and then erroneously enters "newly manufactured parts development," the AI ​​model detects this and generates correction suggestions. Furthermore, the content of the estimate attached to the approval request (e.g., "¥500,000") is extracted using OCR technology and compared with the amount entered in the approval request (e.g., "¥50,000"). If an error is found, the server generates an error message ("Typo detected: 'newly manufactured parts development' → 'new product development'. Amount input error: '¥50,000' → '¥500,000'") and sends it to the terminal. The user can then review the error message and correct the approval request.

[0671] Furthermore, the system has an emotion engine to recognize the user's emotions. The emotion engine collects and analyzes emotional data from facial expressions, voice, and text input patterns while the user is creating the request form. For example, if the user is feeling stressed, the system can recognize that emotion and adjust the way error messages are presented. Specifically, if the emotion engine determines that the user is feeling stressed, the system will display error messages in a gentle, supportive tone.

[0672] Decision maker support system

[0673] The decision maker enters the details of a newly received approval document into their terminal. This information is sent to the server, which searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. For example, if five approval documents related to "new product development" have been found in the past, the server obtains the approval results (two approved, three rejected) and displays them on the decision maker's terminal. This allows the decision maker to make quick and accurate decisions based on past examples.

[0674] Furthermore, the emotion engine recognizes the decision maker's emotional state and suggests a course of action if certain conditions are met. For example, if the emotion engine determines that a decision maker is feeling anxious or uncertain while reviewing past decision results, the system will highlight past success stories and suggest additional reference materials to support the decision maker's decision-making.

[0675] As a specific example, when a user creates a request for approval for a "new product development budget application," the system checks for typos and verifies that the amount matches the estimate. Furthermore, the system recognizes the user's emotions and displays a supportive error message if the user is feeling stressed. Furthermore, if the decision maker is feeling anxious, the system highlights specific success stories while referring to past approval results for similar applications. In this way, the present invention supports the entire process of request proposal and approval through emotion recognition, improving work efficiency and accuracy.

[0676] The processing flow will be explained below.

[0677] Proposer Support System

[0678] Program processing

[0679] Step 1:

[0680] The user enters the contents of the request form into the terminal.

[0681] The user enters information such as the project name, purpose, budget amount, and required documents into the approval form.

[0682] Step 2:

[0683] The terminal sends the entered approval request details to the server.

[0684] The terminal sends the request data to the server via the API using a POST request.

[0685] Step 3:

[0686] The server uses a natural language processing model to check the approval request for spelling and grammatical errors.

[0687] The server inputs the request text into a natural language processing (NLP) model to detect and point out typos and grammatical errors.

[0688] Step 4:

[0689] The server reads the contents of the quotation attached to the request form.

[0690] The server uses optical character recognition (OCR) technology to extract the amount from the quotation and compare it with the amount in the approval document.

[0691] Step 5:

[0692] The server compares the amount stated in the request with the amount extracted from the quotation.

[0693] The server compares the extracted amount information with the amount information on the request form to confirm that they match.

[0694] Step 6:

[0695] The server generates an error message based on the comparison.

[0696] If the server detects an error, it creates an error message and cleans up the contents.

[0697] Step 7:

[0698] Sends any server-generated error messages to the terminal for display to the user.

[0699] The server returns an error message in JSON format to the terminal, and the terminal displays the error message in the user interface (UI).

[0700] Step 8:

[0701] The user corrects the request according to the error message.

[0702] The user checks the error message displayed on the device, corrects the contents of the approval request, and sends the corrected version to the server again.

[0703] Step 9:

[0704] The emotion engine analyzes facial expressions and voice data as the user types.

[0705] The server uses an emotion engine to analyze the user's emotional state and processes the results.

[0706] Step 10:

[0707] The server adjusts how error messages are presented based on the emotion data.

[0708] The server takes appropriate considerations into account the user's emotional state and changes the tone of the error message.

[0709] ---

[0710] Decision maker support system

[0711] Program processing

[0712] Step 1:

[0713] The approver enters the contents of the newly received request into the terminal.

[0714] The approver enters the newly received approval information into the approval form. Example: Project name: "New product development" "Budget: ¥500,000"

[0715] Step 2:

[0716] The terminal sends the contents of the request to the server.

[0717] The terminal sends the request data to the server via the API using a POST request.

[0718] Step 3:

[0719] The server searches for similar requests from a database of past requests.

[0720] The server inputs the details of the request (project name, budget, purpose, etc.) into a natural language processing (NLP) model and searches the database.

[0721] Step 4:

[0722] The server extracts similar approval documents from the search results.

[0723] The server filters past requests based on attributes such as amount, project content, and submitting department, and lists the most matching data.

[0724] Step 5:

[0725] The server obtains the approval results of the extracted past approval documents.

[0726] The server obtains the decision results (approval, rejection, etc.) of the extracted proposals and organizes them along with any error messages.

[0727] Step 6:

[0728] The server sends the approval status of past approval requests to the terminal and presents it to the approver.

[0729] The server returns the approval status in JSON format to the terminal, and the terminal displays the information on the UI.

[0730] Step 7:

[0731] The emotion engine analyzes the emotional state of the decision maker.

[0732] The server uses an emotion engine to analyze the decision maker's emotional state and processes the results.

[0733] Step 8:

[0734] The server proposes a response policy based on the emotion data.

[0735] The server suggests the most appropriate action depending on the decision maker's emotional state, for example by displaying information that emphasizes past success stories.

[0736] ---

[0737] These processing steps provide efficient and accurate support to both the request initiator and the approver. By incorporating an emotion engine, more natural interactions can be achieved that take into consideration the user's emotions, further improving the efficiency and accuracy of work.

[0738] Example 2

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

[0740] The current approval process requires a lot of manual work, which is time-consuming and labor-intensive. It's also prone to typos and input errors, which can delay approval. Furthermore, there's a lack of support that takes into account the feelings of users and decision makers, which can lead to increased stress and anxiety. This creates a need for greater efficiency and accuracy in the process.

[0741] 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 a means including a natural language processing model for detecting typographical errors, a means for extracting numerical information described in the approval request form from the document, and a means for comparing the numerical information described in the approval request form with the numerical information extracted from the document. This makes it possible to automatically detect typographical errors and discrepancies in amounts, thereby reducing the manual work of the user.

[0742] Furthermore, in this invention, the server includes means for generating an error message based on the comparison result, means for presenting the error message to the user, and means including an emotion recognition engine for recognizing the user's emotion and adjusting the way the error message is presented, thereby enabling appropriate support for the user and enabling them to check and correct the error message while reducing stress.

[0743] The server also includes a means including a natural language processing model for searching past approval request data, a means for extracting similar approval requests from the search results, a means for presenting the decision results of the extracted approval requests, and a means including an emotion recognition engine for recognizing the emotions of the decision maker and making suggestions to support the decision-making. This allows the decision maker to make decisions quickly and accurately based on past cases and receive appropriate support.

[0744] A "natural language processing model for detecting typos" is an artificial intelligence technique used to analyze text data and automatically detect typos, spelling errors, and grammatical errors.

[0745] "Means for extracting numerical information contained in a request form from the document" refers to a technology for accurately extracting numerical information such as amounts from attached documents (such as estimates).

[0746] "Means for comparing the numerical information entered in the request form with the numerical information extracted from the document" refers to a technology for comparing the numerical information entered in the request form with the numerical information extracted from the document and checking for matches or mismatches.

[0747] The "means for generating an error message" is a technique for creating a message to notify the user when a typographical error or a mismatch in numerical information is detected.

[0748] "Means for presenting an error message to the user" refers to a technique for displaying the generated error message on the user's terminal screen and prompting the user to correct the error.

[0749] An "emotion recognition engine" is a technology that analyzes the facial expressions, voice, and text input patterns of users and decision makers to recognize emotions such as stress and anxiety.

[0750] "Means for recognizing emotions and adjusting the presentation method of error messages" refers to a technology that adjusts the display method and tone of error messages based on the user's emotional state recognized by an emotion recognition engine.

[0751] The "natural language processing model for searching past approval documents" is an artificial intelligence technology used to search a database of past approval documents and identify similar approval documents.

[0752] "Means for extracting similar approval documents" refers to a technique for selecting approval documents with similar content from past approval documents.

[0753] The "means for presenting the decision results of the extracted request documents" is a technology for displaying the decision results (such as approval or rejection) of the extracted past request documents to the user or authorizer.

[0754] The "emotion recognition engine that makes suggestions to support decision-making" is a technology that recognizes the emotional state of the decision maker and supports the decision-making process by presenting past success stories and additional materials.

[0755] This invention is a system for supporting approval request drafters and approvers, and improves the process more effectively by combining functions for checking for typos, confirming amounts, and referencing past approval request data with an emotion recognition engine that recognizes the user's emotions. This system utilizes AI technology, natural language processing (NLP), optical character recognition (OCR), and emotion recognition technology to provide an efficient and accurate approval request process.

[0756] System Configuration

[0757] Proposer Support System

[0758] The user enters the details of the approval request into the terminal. This includes the project name, purpose, budget, and required documents. The terminal sends this information to the server, which uses a natural language processing model to check for typos and grammatical errors. For example, if the user enters "new product development" and then misspells "new parts development," the server will detect this and generate correction suggestions.

[0759] Next, the content of the quotation attached to the request form (for example, "¥500,000") is extracted using OCR technology and compared with the amount entered in the request form (for example, "¥50,000"). If there is an error, the server generates an error message and sends it to the terminal, stating, "Typo detected: 'New parts development' → 'New product development'. Amount input error: '¥50,000' → '¥500,000'." The user can then check the error message and correct the request form.

[0760] Additionally, the system is equipped with an emotion recognition engine. The emotion recognition engine collects and analyzes emotional data from facial expressions, voice, and text input patterns while the user is creating the request form. For example, if the user is feeling stressed, the system recognizes that emotion and adjusts the way error messages are presented. Specifically, if the emotion recognition engine determines that the user is feeling stressed, the system displays error messages in a gentle, supportive tone.

[0761] Decision maker support system

[0762] The decision maker enters the details of a newly received approval document into their terminal. This information is sent to the server, which searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. For example, if five approval documents related to "new product development" have been found in the past, the server obtains the approval results (two approved, three rejected) and displays them on the decision maker's terminal. This allows the decision maker to make quick and accurate decisions based on past examples.

[0763] Furthermore, the emotion recognition engine recognizes the decision maker's emotional state and suggests a course of action if certain conditions are met. For example, if the emotion recognition engine determines that the decision maker is feeling anxious or uncertain while reviewing past decision results, the system will highlight past success stories and suggest providing additional reference materials.

[0764] Examples and prompts

[0765] Specific examples

[0766] 1. Check for spelling errors in your input

[0767] A user creates a request for approval for a "new product development budget" and mistakenly types "new part development." The server detects this and suggests correcting it to "new product development."

[0768] 2. Check the amount

[0769] If a user enters "¥50,000" in a request form and the attached estimate states "¥500,000," the server will detect this discrepancy and prompt the user to change "¥50,000" to "¥500,000."

[0770] 3. Emotion-based error message display

[0771] If the user is stressed, an emotion recognition engine will detect this and display a gentle error message.

[0772] 4. Reference to past approval documents

[0773] When a decision maker approves a "new product development budget request," they search a database of past approval requests and report that two similar requests have been approved and three have been rejected.

[0774] Prompt Sentence Examples

[0775] 1. "Please check the new product development approval documents for typos and inconsistencies in amounts."

[0776] 2. "Please display error messages in a gentle tone if the user is feeling stressed while creating a request."

[0777] 3. "Search for similar past approval requests and their approval results and display a list."

[0778] 4. "If the decision maker is feeling unsure, highlight past success stories."

[0779] In this way, the system improves the efficiency of the approval process and provides user support through specific implementation examples and prompt statements.

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

[0781] Step 1:

[0782] The user inputs the details of the approval request into the terminal. The input details include the project name, purpose, budget amount, required documents, etc. For example, the user inputs the project name "New product development," the purpose "To improve sales," the budget amount "500,000 yen," and uploads the quotation file. This input information becomes the basic data for the next step.

[0783] Step 2:

[0784] The terminal sends the entered information to the server. Data such as the project name, purpose, budget amount, and attached estimate are transferred to the server via the network. After the server receives this information, it prepares it for the next process.

[0785] Step 3:

[0786] The server uses a natural language processing model to check for typos and grammatical errors. The server inputs the received text data into a natural language processing (NLP) model to detect typos and grammatical errors. For example, if "new parts development" is input incorrectly, the server generates a suggestion to correct this to "new product development." This suggestion is sent to the next step.

[0787] Step 4:

[0788] The server uses OCR technology to extract the amount from the quote and compare it with the amount in the approval request. The server inputs the attached quote file into the OCR module and obtains the extracted amount (e.g., "500,000 yen"). This is then compared with the amount entered in the approval request (e.g., "50,000 yen") to confirm any discrepancies. The result of this comparison becomes the data to proceed to the next step.

[0789] Step 5:

[0790] The server generates an error message and sends it to the terminal. The server generates an error message based on the results of the typo detection and the discrepancy in the amount. For example, an error message such as "Typo detected: 'New parts development' → 'New product development'. Amount input error: '￥50,000' → '￥500,000'" is generated and sent to the terminal. The user confirms this error message.

[0791] Step 6:

[0792] The user checks the error message and corrects the approval request. The user checks the error message on the terminal and makes the necessary corrections. For example, the project name is changed to "New Product Development" and the budget amount is changed to "500,000 yen." This corrected information is sent back to the server and proceeds to the next process.

[0793] Step 7:

[0794] The emotion recognition engine recognizes the user's emotions and generates an appropriate error message. The server uses the emotion recognition engine to collect and analyze emotional data from the user's facial expressions, voice, and text input patterns. For example, if the user is feeling stressed, the system will recognize this and display an error message in a gentle tone. For example, it will display, "Thank you for your hard work. We understand that you are probably feeling stressed, but we have corrected the typo in 'New Parts Development' to 'New Product Development'. You're almost there, keep trying!"

[0795] (Application example 2)

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

[0797] Conventional approval systems lack sufficient means for detecting typos and confirming amounts, and do not provide error messages or decision-making support that take into account the emotional state of the user or approver. Therefore, there is a need to improve the efficiency and accuracy of the approval process. In particular, there is a need for a method to reduce unnecessary rework caused by typos and incorrect amounts, as well as user stress. Furthermore, in factory operations, there is a need to streamline the process of reviewing numerous work instructions and maintenance requests.

[0798] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means including a natural language processing model for detecting typographical errors, means for extracting the amount stated in the request form from the estimate, means for comparing the amount stated in the request form with the amount extracted from the estimate, means including an emotion recognition engine for recognizing the user's emotional state, means for adjusting an error message based on the results of the emotion recognition engine, means for presenting the error message to the user, means including a natural language processing model for searching past request form data, means for extracting similar request forms from the search results, means for presenting the approval result of the extracted request form, means including an emotion recognition engine for recognizing the emotional state of the approver, and means for providing additional reference materials based on the results of the emotion recognition engine. This enables efficient detection and correction of typographical errors and incorrect amounts, and enables appropriate feedback and decision-making support that takes into account the emotional state of the user and the approver.

[0799] "Typographical errors" refers to spelling or typing errors contained in a document.

[0800] "Natural language processing model" refers to a machine learning or AI algorithm designed to understand, generate, or translate natural language.

[0801] "Monetary value extraction" refers to the process of identifying and extracting numerical information contained within a document.

[0802] An "emotion recognition engine" refers to technology that collects and analyzes emotional data from a user's facial expressions, voice, and text input patterns.

[0803] "Error Message" means a message that notifies the user about a problem or error detected by the system.

[0804] "Search Results" means the results obtained from a database or source through a search process.

[0805] "Emotional state" refers to a user's emotional state at a particular point in time.

[0806] "Similar approval documents" refers to past approval document data that has similar content to the current approval document.

[0807] "Decision result" refers to the final approval or rejection of the request.

[0808] "Feedback" refers to the reaction or information that a system provides to a user.

[0809] "Decision support" refers to processes or systems that provide information and tools to help users or decision makers make the best decisions.

[0810] This invention is a system for supporting approval process initiators and approvers, and it improves the process more effectively by combining functions such as checking for typos, confirming amounts, and referencing past approval process data with an emotion engine that recognizes user emotions. This system utilizes AI technology, natural language processing (NLP), optical character recognition (OCR), and emotion recognition technology to provide an efficient and accurate approval process.

[0811] Proposer Support System

[0812] When the drafter enters the contents of the request form into the terminal, a natural language processing model is used to detect typos. The terminal then sends this information to the server, which uses the natural language processing model to check the document for typos and grammatical errors. Additionally, OCR technology is used to extract the amount from the estimate attached to the request form and compare it with the amount entered in the request form. If there is an error, the server generates an error message and sends it to the terminal, allowing the user to review the error message and correct the request form.

[0813] Decision maker support system

[0814] The decision maker enters the details of a newly received approval document into a terminal. This information is sent to a server, which then searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. This allows the decision maker to make decisions quickly and accurately based on past examples.

[0815] Emotion Recognition Engine

[0816] The emotion recognition engine collects and analyzes emotional data from facial expressions, voice, and text input patterns while a user is creating a request for approval. For example, if a user is feeling stressed, the system can recognize that emotion and adjust the way error messages are presented. Additionally, if the emotion recognition engine determines that a decision maker is feeling anxious or uncertain while reviewing past approval results, the system can highlight past success stories and suggest additional reference materials to support the decision maker's decision-making.

[0817] Specific hardware and software

[0818] To implement this system, the following hardware and software are required:

[0819] Hardware: User devices (smartphones, tablets, PCs, etc.), servers, cameras for optical character recognition.

[0820] Software: Natural language processing models (Spacy), optical character recognition software (pytesseract), emotion recognition engines (transformers).

[0821] Examples of concrete examples and prompts

[0822] As an example of a valid use case, consider a factory maintenance request. Here is an example prompt:

[0823] Specific examples

[0824] Input: Image file "maintenance_request.jpg"

[0825] Output: Extracted text: "I would like to request maintenance for Machine A. The budget is 100,000 yen." Suggested correction for typos: "Request -> Check required." Emotion recognition result: "Emotion: Negative, Confidence: 0.85."

[0826] Prompt Sentence Examples

[0827] Extract the text from the image file "maintenance_request.jpg" and check for typos and user sentiment. Also, display the approval results from similar requests in the past.

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

[0829] Step 1:

[0830] The user inputs the details of the approval request into the terminal. The input data includes the project name, purpose, budget amount, required documents, etc. This input data is sent from the terminal to the server.

[0831] Step 2:

[0832] The server checks the received request for typos and grammatical errors using a natural language processing model (Spacy). The input is the text data of the request, and the output is correction suggestions and error messages. The server detects typos and grammatical errors and generates appropriate correction suggestions.

[0833] Step 3:

[0834] Next, the server processes the image of the quotation attached to the request form using optical character recognition software (pytesseract) to extract the amount. The input is the image data of the quotation, and the output is the extracted amount data. The server obtains the amount information as text and compares it with the amount written on the request form.

[0835] Step 4:

[0836] The server compares the amount written in the request form with the amount extracted from the quotation, and generates an error message if there is a discrepancy. The input is the amount data in the request form and the extracted amount data, and the output is an error message. The server detects errors and generates a specific error message.

[0837] Step 5:

[0838] The server uses emotion recognition engines (transformers) to analyze the user's emotional state. The input is facial expression, voice, and text input data while the user is creating the request, and the output is the emotion recognition results. The server evaluates the user's emotional state and recognizes negative emotions such as stress.

[0839] Step 6:

[0840] The server adjusts the presentation of error messages based on the results of the emotion recognition engine. The input is the emotion recognition result, and the output is the adjusted error message. If the user is feeling stressed, the server presents the error message in a gentle, supportive tone.

[0841] Step 7:

[0842] The user checks the error message and corrects any necessary corrections. The input is the error message sent from the server, and the output is the corrected approval request data. The user corrects the approval request based on the error message.

[0843] Step 8:

[0844] The approver inputs the details of a newly received approval document into the terminal. This is sent to the server, which searches a database of past approval documents. The input is the data of the new approval document, and the output is a list of similar past approval documents. The server uses a natural language processing model to search the database and extract similar approval documents.

[0845] Step 9:

[0846] The server presents the approver with a list of similar approval documents from the search results and displays the approval results for each approval document. The input is a list of similar past approval documents, and the output is the display data of the approval results. The server helps the approver make decisions quickly and accurately based on past cases.

[0847] Step 10:

[0848] The emotion recognition engine recognizes the decision maker's emotional state and proposes a course of action if certain conditions are met. The input is the decision maker's facial expression, voice, and text data, and the output is the emotion recognition results and proposal data. If the decision maker has concerns or doubts, the server highlights past success stories and provides additional reference materials.

[0849] Specific actions

[0850] Specific examples

[0851] Input: Image file "maintenance_request.jpg"

[0852] Output: Extracted text: "I would like to request maintenance for Machine A. The budget is 100,000 yen." Suggested correction for typos: "Request -> Check required." Emotion recognition result: "Emotion: Negative, Confidence: 0.85."

[0853] Prompt Sentence Examples

[0854] Extract the text from the image file "maintenance_request.jpg" and check for typos and user sentiment. Also, display the approval results from similar requests in the past.

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

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

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

[0858] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0871] This invention is a system to support the drafter and approver of approval requests, and mainly provides functions for checking for typos, confirming amounts, and referencing past approval request data. This system utilizes AI technology, natural language processing (NLP) and optical character recognition (OCR) technologies to provide an efficient and accurate approval process.

[0872] Proposer Support System

[0873] The user enters the details of the approval request into the terminal. This includes the project name, objectives, budget, and required documents. The terminal then sends this information to the server, where a natural language processing model is used to check for typos and grammatical errors. For example, if the user enters "new product development" but misspells "new parts development," the AI ​​model detects this and generates correction suggestions. Furthermore, the content of the estimate attached to the approval request (e.g., "¥500,000") is extracted using OCR technology and compared with the amount entered in the approval request (e.g., "¥50,000"). If an error is found, the server generates an error message ("Typo detected: 'New parts development' → 'New product development'. Amount input error: '¥50,000' → '¥500,000'") and sends it to the terminal. The user can then review the error message and correct the approval request.

[0874] Decision maker support system

[0875] The decision maker enters the details of a newly received approval document into their terminal. This information is sent to the server, which searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. For example, if five approval documents related to "new product development" have been found in the past, the server obtains the approval results (two approved, three rejected) and displays them on the decision maker's terminal. This allows the decision maker to make quick and accurate decisions based on past examples.

[0876] As a specific example, when a user creates a request for approval for a "new product development budget application," the system checks for typos and omissions and confirms that the amount matches the estimate. The system also allows the approver to refer to the approval results of similar requests in the past, making the process more efficient. In this way, the present invention supports the approval process, improving work efficiency and accuracy.

[0877] The processing flow will be explained below.

[0878] Proposer Support System

[0879] Program processing

[0880] Step 1:

[0881] The user enters the contents of the request form into the terminal.

[0882] The user enters information such as the project name, purpose, budget amount, and required documents into the approval form.

[0883] Step 2:

[0884] The terminal sends the entered approval request details to the server.

[0885] The terminal sends the request data to the server via the API using a POST request.

[0886] Step 3:

[0887] The server uses a natural language processing model to check the approval request for spelling and grammatical errors.

[0888] The server inputs the request text into a natural language processing (NLP) model to detect and point out typos and grammatical errors.

[0889] Step 4:

[0890] The server reads the contents of the quotation attached to the request form.

[0891] The server uses optical character recognition (OCR) technology to extract the amount from the quotation and compare it with the amount in the approval document.

[0892] Step 5:

[0893] The server compares the amount stated in the request with the amount extracted from the quotation.

[0894] The server compares the extracted amount information with the amount information on the request form to confirm that they match.

[0895] Step 6:

[0896] The server generates an error message based on the comparison.

[0897] If the server detects an error, it creates an error message and cleans up the contents.

[0898] Step 7:

[0899] Sends any server-generated error messages to the terminal for display to the user.

[0900] The server returns an error message in JSON format to the terminal, and the terminal displays the error message in the user interface (UI).

[0901] Step 8:

[0902] The user corrects the request according to the error message.

[0903] The user checks the error message displayed on the device, corrects the contents of the approval request, and sends the corrected version to the server again.

[0904] ---

[0905] Decision maker support system

[0906] Program processing

[0907] Step 1:

[0908] The approver enters the contents of the newly received request into the terminal.

[0909] The approver enters the newly received approval information into the approval form. Example: Project name: "New product development" "Budget: ¥500,000"

[0910] Step 2:

[0911] The terminal sends the contents of the request to the server.

[0912] The terminal sends the request data to the server via the API using a POST request.

[0913] Step 3:

[0914] The server searches for similar requests from a database of past requests.

[0915] The server inputs the details of the request (project name, budget, purpose, etc.) into a natural language processing (NLP) model and searches the database.

[0916] Step 4:

[0917] The server extracts similar approval documents from the search results.

[0918] The server filters past requests based on attributes such as amount, project content, and submitting department, and lists the most matching data.

[0919] Step 5:

[0920] The server obtains the approval results of the extracted past approval documents.

[0921] The server obtains the decision results (approval, rejection, etc.) of the extracted proposals and organizes them along with any error messages.

[0922] Step 6:

[0923] The server sends the approval status of past approval requests to the terminal and presents it to the approver.

[0924] The server returns the approval status in JSON format to the terminal, and the terminal displays the information on the UI.

[0925] Example 1

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

[0927] In the conventional approval process, the proposer had to manually check the approval document for typos and grammatical errors, and also manually check for discrepancies between the amount listed on the estimate and the amount listed on the approval document. This made it prone to errors and increased the likelihood of delays in the approval process. Furthermore, the approver had to manually search past approval document data and refer to the approval results of similar approval documents, making it difficult to make efficient decisions. A solution to these problems was needed.

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

[0929] In this invention, the server includes: a means for a user to input the contents of a request form into a terminal and the terminal transmits this information to the server; a means including a natural language processing model for detecting typographical errors; optical character recognition means for extracting the amount stated in the request form from an estimate; means for comparing the amount stated in the request form with the amount extracted from the estimate; means for generating an error message based on the comparison result; and means for presenting the error message to the user. This allows the drafter to automatically detect and correct typographical errors and discrepancies in the amount in the request form, thereby realizing an efficient and error-free request process. The server also includes a means including a natural language processing model for searching past request form data; means for extracting similar request forms from the search results; and means for presenting the approval results of the extracted request forms. This allows the decision maker to quickly refer to data on similar past request forms and make decisions efficiently.

[0930] A "user" is someone who inputs the contents of a request form and checks error messages from the system.

[0931] A "terminal" is an electronic device that a user uses to input the contents of a request form and exchange information with a server.

[0932] A "server" is a central processing unit that receives information sent by a user, processes it, and returns the results to the terminal.

[0933] A "requisition form" is a document that lists the project name, purpose, budget amount, and required documents, and is used for approval procedures within a company.

[0934] A "natural language processing model" is a machine learning model that analyzes text data to detect typos and grammatical errors.

[0935] "Typographical errors" refer to typos or input errors contained in the text content of a request form.

[0936] "Optical character recognition" is a technology that extracts character information from images or documents such as PDF files.

[0937] An "quote" is a document that lists the budget amount and detailed expenses, and is attached to a request form.

[0938] The "comparison method" is a method for comparing the amount stated in the request form with the amount extracted from the estimate to determine whether they match or not.

[0939] An "error message" is information that notifies the user of problems with the request form, such as typos or mismatched amounts.

[0940] The "search method" is a technology for searching past approval request data from a database.

[0941] A "similar request form" is a past request form whose content is similar to that of the current request form.

[0942] "Decision result" refers to the result of approval or rejection of a past request for approval.

[0943] This invention is a system to support the drafter and approver of approval requests, primarily by checking for typos, confirming amounts, and providing functions for referencing past approval request data. The system utilizes AI technology, natural language processing (NLP) and optical character recognition (OCR) technologies, to provide an efficient and accurate approval process.

[0944] First, the user inputs the details of the request into the device. This information includes the project name, purpose, budget, and required documents. The device then sends this information to the server, which uses a natural language processing model (e.g., BERT or GPT-3) to check for typos and grammatical errors.

[0945] For example, if a user accidentally types "new product development" instead of "new parts development," the AI ​​model detects the error and generates the correct spelling, "new product development," as a correction suggestion. Also, when a user uploads a quote (e.g., a PDF file) attached to a request form to their device, the quote is sent from the device to the server. The server uses OCR technology (e.g., Tesseract OCR) to extract the amount information from the quote. The server compares the extracted amount (e.g., "¥500,000") with the amount written in the request form (e.g., "¥50,000") and generates a correction suggestion if there is an error.

[0946] The server compiles these correction suggestions and generates an error message (e.g., "Typo detected: 'New parts development' → 'New product development'. Amount input error: '￥50,000' → '￥500,000'.") and sends it to the terminal. The user can check the error message and correct the approval request.

[0947] Next, the approver enters the details of the newly received approval document into their terminal and sends it to the server. The server uses a natural language processing model to search a database of past approval documents, searching for past approval documents with similar amounts, project details, and submitting departments. For example, if five past approval documents related to "new product development" are found, the server obtains the approval results (two approved, three rejected) and displays them on the approver's terminal. This enables the approver to make quick and accurate decisions based on past examples.

[0948] An example of a specific prompt is:

[0949] 1. Typo detection: "Detect typos in this text: New parts development"

[0950] 2. OCR processing of quote: "Please extract the amount from this PDF file"

[0951] 3. Search for similar approval documents: "Search for past approval documents similar to the following: Project name = New product development, Budget = ¥500,000"

[0952] This system allows users and decision makers to work efficiently and accurately during the approval process, minimizing errors.

[0953] In this way, the present invention is a system that supports the process of drafting and approving requests, and aims to improve the efficiency and accuracy of business operations.

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

[0955] Proposer Support System

[0956] Step 1:

[0957] The user enters the details of the approval request.

[0958] Input: Project name, purpose, budget amount, required documents, and other information on the approval request

[0959] Output: Input information is saved to the terminal

[0960] The user enters the project name (e.g., "New product development"), purpose (e.g., "Market expansion"), budget amount (e.g., "500,000 yen"), and required documents (e.g., "Quote") into a form on the device. The device converts the input data into JSON format and sends it to the server.

[0961] Step 2:

[0962] The device sends the input information to the server

[0963] Input: Approval information entered by the user on the device (JSON format)

[0964] Output: Approval information sent to the server

[0965] The device converts the user's input into JSON format and sends it to the server. This information includes the project name, purpose, budget, and required documents.

[0966] Step 3:

[0967] The server uses natural language processing models to detect spelling errors

[0968] Input: JSON formatted approval document information received on the server

[0969] Output: Detected spelling and grammatical errors (correction suggestions)

[0970] The server passes the received JSON data to a natural language processing model (e.g., BERT or GPT-3), which detects typos (e.g., "new parts development" → "new product development") and grammatical errors in the sentence and returns correction suggestions.

[0971] Step 4:

[0972] User uploads a quote

[0973] Input: Digital quotation in PDF format

[0974] Output: Quote file saved on the device

[0975] The user uploads a quote (e.g., PDF format) to the device, which saves the quote and sends it to the server for further processing.

[0976] Step 5:

[0977] The device sends the estimate to the server

[0978] Input: Quote file uploaded by user

[0979] Output: Quote file sent to the server

[0980] The terminal sends the saved quotation file to the server.

[0981] Step 6:

[0982] The server uses OCR technology to extract the amount from the quote.

[0983] Input: Quotation file that arrived on the server

[0984] Output: Extracted amount data (e.g., "￥500,000")

[0985] The server uses OCR technology (e.g., Tesseract OCR) to extract the amount from the quote. For example, it extracts "￥500,000" as the amount in the quote.

[0986] Step 7:

[0987] The server compares the amount in the request form with the amount in the quotation

[0988] Input: Amount stated in the request and amount extracted from the estimate

[0989] Output: Amount match / mismatch detection result (correction suggestions if there are differences)

[0990] The server compares the extracted amount (e.g., "500,000 yen") with the amount stated in the approval request (e.g., "50,000 yen"), and if there is an error, generates a correction suggestion (e.g., "500,000 yen").

[0991] Step 8:

[0992] The server generates an error message

[0993] Input: Detected results of spelling errors, grammatical errors, and amount matches / mismatches

[0994] Output: Generated error message (e.g., "Typo detected: 'New parts development' → 'New product development'. Amount input error: '￥50,000' → '￥500,000'.")

[0995] The server generates error messages based on typos, grammar errors, and matched / mismatched amounts.

[0996] Step 9:

[0997] The server sends an error message to the terminal.

[0998] Input: The generated error message

[0999] Output: Error message sent to terminal

[1000] The server generates an error message and sends it to the terminal, allowing the user to review it and correct the contents of the request form.

[1001] Decision maker support system

[1002] Step 1:

[1003] The approver submits a new approval document to the server.

[1004] Input: The content of the new approval request entered by the approver into the terminal

[1005] Output: Approval information sent to the server

[1006] The decision maker enters a new request form on the terminal and sends it to the server.

[1007] Step 2:

[1008] The server searches the approval document database

[1009] Input: Contents of new approval request

[1010] Output: List of similar past approval documents found

[1011] The server searches a database of past approval requests using a natural language processing model (e.g., BERT or GPT-3) to extract approval requests with similar project names, budget amounts, and submitting departments.

[1012] Step 3:

[1013] The server obtains the approval result and displays it on the terminal.

[1014] Input: List of similar past approval documents

[1015] Output: Approval results of similar approval documents displayed on the terminal (e.g., 5 approval documents related to "new product development" were found, of which 2 were approved and 3 were rejected)

[1016] The server lists the search results and sends them to the approver's device along with past approval decisions. The approver makes a decision on the current approval decision, referring to the approval decisions of similar past approval decisions.

[1017] In this way, systems that support users and decision makers can streamline and improve the accuracy of the request document creation and approval process.

[1018] (Application example 1)

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

[1020] The traditional approval process required a lot of manual work, and there were frequent problems with typos and discrepancies in amounts. Searching for similar approval documents in the past was also inefficient, making it difficult to make quick decisions. While there is a particular need for more efficient approval process in factories, the lack of systems to automate current procedures has hindered improvements in efficiency and accuracy.

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

[1022] In this invention, the server includes: means for detecting typos and omissions, means for including a natural language processing model, means for including optical character recognition technology for extracting the amount stated in the request form from the estimate, means for comparing the amount stated in the request form with the amount extracted from the estimate, means for including a generative AI model for generating an error message based on the comparison result, means for generating a prompt sentence for presenting the error message to the user, means for scanning the request form and extracting text information, means for including a natural language processing model for searching past request form data, means for extracting similar request forms from the search results, and means for presenting the approval results of the extracted request form. This enables the efficiency and accuracy of the request form creation and approval process to be improved.

[1023] A "natural language processing model for detecting typos and misspellings" is an algorithm that automatically detects spelling and grammatical errors in a sentence and suggests corrections.

[1024] "Optical character recognition technology for extracting amounts from estimates" is a technology that extracts text information, particularly amounts, as digital data from images of estimates read by a scanner or camera.

[1025] A "generative AI model that generates error messages" is an artificial intelligence model that automatically generates error messages based on detected error information such as typos or mismatched amounts.

[1026] The "means for generating a prompt sentence" is a means for automatically generating an instruction sentence or a confirmation message to be presented to the user.

[1027] "Means of scanning approval documents and extracting text information" refers to technology for digitizing physical approval documents and obtaining text data from them.

[1028] The "natural language processing model for searching past approval request data" is an algorithm for analyzing a database of previously submitted approval requests and searching for and retrieving related information.

[1029] The "means for extracting similar approval documents" refers to a means for identifying and extracting approval documents whose contents are similar to the current approval document from a database of past approval documents.

[1030] The "means for presenting the decision results" is a means for obtaining the decision results of past approval requests and providing them to the user as information.

[1031] To implement this invention, a system is constructed that supports the process from receipt of approval documents to approval. Specifically, this system uses the following hardware and software:

[1032] Hardware:

[1033] Factory robot: Used for scanning approval documents and user interface

[1034] Scanner: Used to digitize physical documents and estimates

[1035] Server: processes and stores data

[1036] software:

[1037] OCR engine (Tesseract): Extracts text information from scanned documents

[1038] Natural language processing library (spaCy): used for text analysis, typo detection, and historical data search

[1039] Database (PostgreSQL): Store and search past approval documents

[1040] Program operation description:

[1041] 1. Scanning the approval document:

[1042] The terminal (factory robot) uses a scanner to read the approval document submitted by the user. The scanned image data is sent to the server, which then analyzes it with an OCR engine (Tesseract) and extracts the text data.

[1043] 2. Check for typos:

[1044] The extracted text data is analyzed on the server using a natural language processing library (spaCy). This analysis detects typos and omissions in the request form. The detection results are input into a generative AI model, which generates an error message along with suggested corrections.

[1045] 3. Amount Verification:

[1046] The amount written on the request form and the amount written on the quotation are extracted using OCR technology and automatically compared on the server. If they do not match, an error message is generated by the generative AI model.

[1047] 4. Searching historical data:

[1048] The server uses a natural language processing library to search a database of past approval documents (PostgreSQL) and extracts cases similar to the current approval document, allowing the approver to refer to past approval results.

[1049] 5. User Feedback:

[1050] Generated error messages and approval results for past approval requests are displayed as prompts on the terminal (factory robot) display so that the user can check them.

[1051] Examples:

[1052] For example, suppose a factory's A-Robot receives a new approval document, which is a "budget request for new product development." The robot first scans the document and extracts text information using an OCR engine. The server receives the text data and analyzes it using a natural language processing library (spaCy) to check for typos. The quotation is also scanned in the same way, and the amount is extracted. If the amount on the approval document and the quotation do not match, for example, if ¥500,000 is entered as ¥50,000, the generative AI model generates an error message.

[1053] Furthermore, the server searches for similar past requests for approval, and if, for example, there have been three similar "new product development" requests in the past, the approval results (e.g., two approved, one rejected) are displayed on the robot's screen.

[1054] Example prompt sentence:

[1055] The "New Product Development Budget Request" approval form has been scanned. Please check for typos and confirm that the amount is correct: 500,000 yen. Search for similar approval forms in the past and view the approval results.

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

[1057] Step 1:

[1058] When a user submits a request for approval, the terminal (factory robot) scans the request and sends the scanned image data to an OCR engine (Tesseract) to extract text information.

[1059] Input: Scanned image data of the approval document

[1060] Output: Extracted text data

[1061] Step 2:

[1062] The server receives the extracted text data and uses a natural language processing library (spaCy) to detect typos and omissions, and the detection results also include suggested corrections.

[1063] Input: Extracted text data

[1064] Output: Misspelling detection results (including correction suggestions)

[1065] Step 3:

[1066] The user also scans the quote using a scanner and sends the image data to the OCR engine, which extracts the quote amount.

[1067] Input: Scanned image data of quote

[1068] Output: Amount data extracted from the quotation

[1069] Step 4:

[1070] The server compares the amount data in the request and the quotation, and if the amounts do not match, the generative AI model automatically generates an error message.

[1071] Input: Amount data extracted from the approval document, amount data extracted from the quotation

[1072] Output: Error message

[1073] Step 5:

[1074] The server searches a database of past approval requests and uses a natural language processing library to extract requests similar to the current one.

[1075] Input: Text data of the approval request

[1076] Output: Similar past approval documents

[1077] Step 6:

[1078] The server generates a message showing the past approval results based on the extracted past approval request data. This message including the approval results is sent to the terminal (factory robot) and displayed to the user.

[1079] Input: Similar past approval documents data

[1080] Output: Past approval results and suggested messages

[1081] Step 7:

[1082] The user checks the error messages and past approval results displayed on the factory robot's display and makes corrections to the approval document as necessary.

[1083] Input: Error messages, past approval results

[1084] Output: Modified decision (if necessary)

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

[1086] This invention is a system for supporting approval process initiators and approvers, and improves the process more effectively by combining functions such as checking for typos, confirming amounts, and referencing past approval process data with an emotion engine that recognizes user emotions. This system utilizes AI technology, natural language processing (NLP), optical character recognition (OCR), and emotion recognition technology to provide an efficient and accurate approval process.

[1087] Proposer Support System

[1088] The user enters the details of the approval request into the terminal. This includes the project name, objectives, budget, and required documents. The terminal then sends this information to the server, where a natural language processing model is used to check for typos and grammatical errors. For example, if the user enters "new product development" and then erroneously enters "newly manufactured parts development," the AI ​​model detects this and generates correction suggestions. Furthermore, the content of the estimate attached to the approval request (e.g., "¥500,000") is extracted using OCR technology and compared with the amount entered in the approval request (e.g., "¥50,000"). If an error is found, the server generates an error message ("Typo detected: 'newly manufactured parts development' → 'new product development'. Amount input error: '¥50,000' → '¥500,000'") and sends it to the terminal. The user can then review the error message and correct the approval request.

[1089] Furthermore, the system has an emotion engine to recognize the user's emotions. The emotion engine collects and analyzes emotional data from facial expressions, voice, and text input patterns while the user is creating the request form. For example, if the user is feeling stressed, the system can recognize that emotion and adjust the way error messages are presented. Specifically, if the emotion engine determines that the user is feeling stressed, the system will display error messages in a gentle, supportive tone.

[1090] Decision maker support system

[1091] The decision maker enters the details of a newly received approval document into their terminal. This information is sent to the server, which searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. For example, if five approval documents related to "new product development" have been found in the past, the server obtains the approval results (two approved, three rejected) and displays them on the decision maker's terminal. This allows the decision maker to make quick and accurate decisions based on past examples.

[1092] Furthermore, the emotion engine recognizes the decision maker's emotional state and suggests a course of action if certain conditions are met. For example, if the emotion engine determines that a decision maker is feeling anxious or uncertain while reviewing past decision results, the system will highlight past success stories and suggest additional reference materials to support the decision maker's decision-making.

[1093] As a specific example, when a user creates a request for approval for a "new product development budget application," the system checks for typos and verifies that the amount matches the estimate. Furthermore, the system recognizes the user's emotions and displays a supportive error message if the user is feeling stressed. Furthermore, if the decision maker is feeling anxious, the system highlights specific success stories while referring to past approval results for similar applications. In this way, the present invention supports the entire process of request proposal and approval through emotion recognition, improving work efficiency and accuracy.

[1094] The processing flow will be explained below.

[1095] Proposer Support System

[1096] Program processing

[1097] Step 1:

[1098] The user enters the contents of the request form into the terminal.

[1099] The user enters information such as the project name, purpose, budget amount, and required documents into the approval form.

[1100] Step 2:

[1101] The terminal sends the entered approval request details to the server.

[1102] The terminal sends the request data to the server via the API using a POST request.

[1103] Step 3:

[1104] The server uses a natural language processing model to check the approval request for spelling and grammatical errors.

[1105] The server inputs the request text into a natural language processing (NLP) model to detect and point out typos and grammatical errors.

[1106] Step 4:

[1107] The server reads the contents of the quotation attached to the request form.

[1108] The server uses optical character recognition (OCR) technology to extract the amount from the quotation and compare it with the amount in the approval document.

[1109] Step 5:

[1110] The server compares the amount stated in the request with the amount extracted from the quotation.

[1111] The server compares the extracted amount information with the amount information on the request form to confirm that they match.

[1112] Step 6:

[1113] The server generates an error message based on the comparison.

[1114] If the server detects an error, it creates an error message and cleans up the contents.

[1115] Step 7:

[1116] Sends any server-generated error messages to the terminal for display to the user.

[1117] The server returns an error message in JSON format to the terminal, and the terminal displays the error message in the user interface (UI).

[1118] Step 8:

[1119] The user corrects the request according to the error message.

[1120] The user checks the error message displayed on the device, corrects the contents of the approval request, and sends the corrected version to the server again.

[1121] Step 9:

[1122] The emotion engine analyzes facial expressions and voice data as the user types.

[1123] The server uses an emotion engine to analyze the user's emotional state and processes the results.

[1124] Step 10:

[1125] The server adjusts how error messages are presented based on the emotion data.

[1126] The server takes appropriate considerations into account the user's emotional state and changes the tone of the error message.

[1127] ---

[1128] Decision maker support system

[1129] Program processing

[1130] Step 1:

[1131] The approver enters the contents of the newly received request into the terminal.

[1132] The approver enters the newly received approval information into the approval form. Example: Project name: "New product development" "Budget: ¥500,000"

[1133] Step 2:

[1134] The terminal sends the contents of the request to the server.

[1135] The terminal sends the request data to the server via the API using a POST request.

[1136] Step 3:

[1137] The server searches for similar requests from a database of past requests.

[1138] The server inputs the details of the request (project name, budget, purpose, etc.) into a natural language processing (NLP) model and searches the database.

[1139] Step 4:

[1140] The server extracts similar approval documents from the search results.

[1141] The server filters past requests based on attributes such as amount, project content, and submitting department, and lists the most matching data.

[1142] Step 5:

[1143] The server obtains the approval results of the extracted past approval documents.

[1144] The server obtains the decision results (approval, rejection, etc.) of the extracted proposals and organizes them along with any error messages.

[1145] Step 6:

[1146] The server sends the approval status of past approval requests to the terminal and presents it to the approver.

[1147] The server returns the approval status in JSON format to the terminal, and the terminal displays the information on the UI.

[1148] Step 7:

[1149] The emotion engine analyzes the emotional state of the decision maker.

[1150] The server uses an emotion engine to analyze the decision maker's emotional state and processes the results.

[1151] Step 8:

[1152] The server proposes a response policy based on the emotion data.

[1153] The server suggests the most appropriate action depending on the decision maker's emotional state, for example by displaying information that emphasizes past success stories.

[1154] ---

[1155] These processing steps provide efficient and accurate support to both the request initiator and the approver. By incorporating an emotion engine, more natural interactions can be achieved that take into consideration the user's emotions, further improving the efficiency and accuracy of work.

[1156] Example 2

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

[1158] The current approval process requires a lot of manual work, which is time-consuming and labor-intensive. It's also prone to typos and input errors, which can delay approval. Furthermore, there's a lack of support that takes into account the feelings of users and decision makers, which can lead to increased stress and anxiety. This creates a need for greater efficiency and accuracy in the process.

[1159] 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 a means including a natural language processing model for detecting typographical errors, a means for extracting numerical information described in the approval request form from the document, and a means for comparing the numerical information described in the approval request form with the numerical information extracted from the document. This makes it possible to automatically detect typographical errors and discrepancies in amounts, thereby reducing the manual work of the user.

[1160] Furthermore, in this invention, the server includes means for generating an error message based on the comparison result, means for presenting the error message to the user, and means including an emotion recognition engine for recognizing the user's emotion and adjusting the way the error message is presented, thereby enabling appropriate support for the user and enabling them to check and correct the error message while reducing stress.

[1161] The server also includes a means including a natural language processing model for searching past approval request data, a means for extracting similar approval requests from the search results, a means for presenting the decision results of the extracted approval requests, and a means including an emotion recognition engine for recognizing the emotions of the decision maker and making suggestions to support the decision-making. This allows the decision maker to make decisions quickly and accurately based on past cases and receive appropriate support.

[1162] A "natural language processing model for detecting typos" is an artificial intelligence technique used to analyze text data and automatically detect typos, spelling errors, and grammatical errors.

[1163] "Means for extracting numerical information contained in a request form from the document" refers to a technology for accurately extracting numerical information such as amounts from attached documents (such as estimates).

[1164] "Means for comparing the numerical information entered in the request form with the numerical information extracted from the document" refers to a technology for comparing the numerical information entered in the request form with the numerical information extracted from the document and checking for matches or mismatches.

[1165] The "means for generating an error message" is a technique for creating a message to notify the user when a typographical error or a mismatch in numerical information is detected.

[1166] "Means for presenting an error message to the user" refers to a technique for displaying the generated error message on the user's terminal screen and prompting the user to correct the error.

[1167] An "emotion recognition engine" is a technology that analyzes the facial expressions, voice, and text input patterns of users and decision makers to recognize emotions such as stress and anxiety.

[1168] "Means for recognizing emotions and adjusting the presentation method of error messages" refers to a technology that adjusts the display method and tone of error messages based on the user's emotional state recognized by an emotion recognition engine.

[1169] The "natural language processing model for searching past approval documents" is an artificial intelligence technology used to search a database of past approval documents and identify similar approval documents.

[1170] "Means for extracting similar approval documents" refers to a technique for selecting approval documents with similar content from past approval documents.

[1171] The "means for presenting the decision results of the extracted request documents" is a technology for displaying the decision results (such as approval or rejection) of the extracted past request documents to the user or authorizer.

[1172] The "emotion recognition engine that makes suggestions to support decision-making" is a technology that recognizes the emotional state of the decision maker and supports the decision-making process by presenting past success stories and additional materials.

[1173] This invention is a system for supporting approval request drafters and approvers, and improves the process more effectively by combining functions for checking for typos, confirming amounts, and referencing past approval request data with an emotion recognition engine that recognizes the user's emotions. This system utilizes AI technology, natural language processing (NLP), optical character recognition (OCR), and emotion recognition technology to provide an efficient and accurate approval request process.

[1174] System Configuration

[1175] Proposer Support System

[1176] The user enters the details of the approval request into the terminal. This includes the project name, purpose, budget, and required documents. The terminal sends this information to the server, which uses a natural language processing model to check for typos and grammatical errors. For example, if the user enters "new product development" and then misspells "new parts development," the server will detect this and generate correction suggestions.

[1177] Next, the content of the quotation attached to the request form (for example, "¥500,000") is extracted using OCR technology and compared with the amount entered in the request form (for example, "¥50,000"). If there is an error, the server generates an error message and sends it to the terminal, stating, "Typo detected: 'New parts development' → 'New product development'. Amount input error: '¥50,000' → '¥500,000'." The user can then check the error message and correct the request form.

[1178] Additionally, the system is equipped with an emotion recognition engine. The emotion recognition engine collects and analyzes emotional data from facial expressions, voice, and text input patterns while the user is creating the request form. For example, if the user is feeling stressed, the system recognizes that emotion and adjusts the way error messages are presented. Specifically, if the emotion recognition engine determines that the user is feeling stressed, the system displays error messages in a gentle, supportive tone.

[1179] Decision maker support system

[1180] The decision maker enters the details of a newly received approval document into their terminal. This information is sent to the server, which searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. For example, if five approval documents related to "new product development" have been found in the past, the server obtains the approval results (two approved, three rejected) and displays them on the decision maker's terminal. This allows the decision maker to make quick and accurate decisions based on past examples.

[1181] Furthermore, the emotion recognition engine recognizes the decision maker's emotional state and suggests a course of action if certain conditions are met. For example, if the emotion recognition engine determines that the decision maker is feeling anxious or uncertain while reviewing past decision results, the system will highlight past success stories and suggest providing additional reference materials.

[1182] Examples and prompts

[1183] Specific examples

[1184] 1. Check for spelling errors in your input

[1185] A user creates a request for approval for a "new product development budget" and mistakenly types "new part development." The server detects this and suggests correcting it to "new product development."

[1186] 2. Check the amount

[1187] If a user enters "¥50,000" in a request form and the attached estimate states "¥500,000," the server will detect this discrepancy and prompt the user to change "¥50,000" to "¥500,000."

[1188] 3. Emotion-based error message display

[1189] If the user is stressed, an emotion recognition engine will detect this and display a gentle error message.

[1190] 4. Reference to past approval documents

[1191] When a decision maker approves a "new product development budget request," they search a database of past approval requests and report that two similar requests have been approved and three have been rejected.

[1192] Prompt Sentence Examples

[1193] 1. "Please check the new product development approval documents for typos and inconsistencies in amounts."

[1194] 2. "Please display error messages in a gentle tone if the user is feeling stressed while creating a request."

[1195] 3. "Search for similar past approval requests and their approval results and display a list."

[1196] 4. "If the decision maker is feeling unsure, highlight past success stories."

[1197] In this way, the system improves the efficiency of the approval process and provides user support through specific implementation examples and prompt statements.

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

[1199] Step 1:

[1200] The user inputs the details of the approval request into the terminal. The input details include the project name, purpose, budget amount, required documents, etc. For example, the user inputs the project name "New product development," the purpose "To improve sales," the budget amount "500,000 yen," and uploads the quotation file. This input information becomes the basic data for the next step.

[1201] Step 2:

[1202] The terminal sends the entered information to the server. Data such as the project name, purpose, budget amount, and attached estimate are transferred to the server via the network. After the server receives this information, it prepares it for the next process.

[1203] Step 3:

[1204] The server uses a natural language processing model to check for typos and grammatical errors. The server inputs the received text data into a natural language processing (NLP) model to detect typos and grammatical errors. For example, if "new parts development" is input incorrectly, the server generates a suggestion to correct this to "new product development." This suggestion is sent to the next step.

[1205] Step 4:

[1206] The server uses OCR technology to extract the amount from the quote and compare it with the amount in the approval request. The server inputs the attached quote file into the OCR module and obtains the extracted amount (e.g., "500,000 yen"). This is then compared with the amount entered in the approval request (e.g., "50,000 yen") to confirm any discrepancies. The result of this comparison becomes the data to proceed to the next step.

[1207] Step 5:

[1208] The server generates an error message and sends it to the terminal. The server generates an error message based on the results of the typo detection and the discrepancy in the amount. For example, an error message such as "Typo detected: 'New parts development' → 'New product development'. Amount input error: '￥50,000' → '￥500,000'" is generated and sent to the terminal. The user confirms this error message.

[1209] Step 6:

[1210] The user checks the error message and corrects the approval request. The user checks the error message on the terminal and makes the necessary corrections. For example, the project name is changed to "New Product Development" and the budget amount is changed to "500,000 yen." This corrected information is sent back to the server and proceeds to the next process.

[1211] Step 7:

[1212] The emotion recognition engine recognizes the user's emotions and generates an appropriate error message. The server uses the emotion recognition engine to collect and analyze emotional data from the user's facial expressions, voice, and text input patterns. For example, if the user is feeling stressed, the system will recognize this and display an error message in a gentle tone. For example, it will display, "Thank you for your hard work. We understand that you are probably feeling stressed, but we have corrected the typo in 'New Parts Development' to 'New Product Development'. You're almost there, keep trying!"

[1213] (Application example 2)

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

[1215] Conventional approval systems lack sufficient means for detecting typos and confirming amounts, and do not provide error messages or decision-making support that take into account the emotional state of the user or approver. Therefore, there is a need to improve the efficiency and accuracy of the approval process. In particular, there is a need for a method to reduce unnecessary rework caused by typos and incorrect amounts, as well as user stress. Furthermore, in factory operations, there is a need to streamline the process of reviewing numerous work instructions and maintenance requests.

[1216] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means including a natural language processing model for detecting typographical errors, means for extracting the amount stated in the request form from the estimate, means for comparing the amount stated in the request form with the amount extracted from the estimate, means including an emotion recognition engine for recognizing the user's emotional state, means for adjusting an error message based on the results of the emotion recognition engine, means for presenting the error message to the user, means including a natural language processing model for searching past request form data, means for extracting similar request forms from the search results, means for presenting the approval result of the extracted request form, means including an emotion recognition engine for recognizing the emotional state of the approver, and means for providing additional reference materials based on the results of the emotion recognition engine. This enables efficient detection and correction of typographical errors and incorrect amounts, and enables appropriate feedback and decision-making support that takes into account the emotional state of the user and the approver.

[1217] "Typographical errors" refers to spelling or typing errors contained in a document.

[1218] "Natural language processing model" refers to a machine learning or AI algorithm designed to understand, generate, or translate natural language.

[1219] "Monetary value extraction" refers to the process of identifying and extracting numerical information contained within a document.

[1220] An "emotion recognition engine" refers to technology that collects and analyzes emotional data from a user's facial expressions, voice, and text input patterns.

[1221] "Error Message" means a message that notifies the user about a problem or error detected by the system.

[1222] "Search Results" means the results obtained from a database or source through a search process.

[1223] "Emotional state" refers to a user's emotional state at a particular point in time.

[1224] "Similar approval documents" refers to past approval document data that has similar content to the current approval document.

[1225] "Decision result" refers to the final approval or rejection of the request.

[1226] "Feedback" refers to the reaction or information that a system provides to a user.

[1227] "Decision support" refers to processes or systems that provide information and tools to help users or decision makers make the best decisions.

[1228] This invention is a system for supporting approval process initiators and approvers, and it improves the process more effectively by combining functions such as checking for typos, confirming amounts, and referencing past approval process data with an emotion engine that recognizes user emotions. This system utilizes AI technology, natural language processing (NLP), optical character recognition (OCR), and emotion recognition technology to provide an efficient and accurate approval process.

[1229] Proposer Support System

[1230] When the drafter enters the contents of the request form into the terminal, a natural language processing model is used to detect typos. The terminal then sends this information to the server, which uses the natural language processing model to check the document for typos and grammatical errors. Additionally, OCR technology is used to extract the amount from the estimate attached to the request form and compare it with the amount entered in the request form. If there is an error, the server generates an error message and sends it to the terminal, allowing the user to review the error message and correct the request form.

[1231] Decision maker support system

[1232] The decision maker enters the details of a newly received approval document into a terminal. This information is sent to a server, which then searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. This allows the decision maker to make decisions quickly and accurately based on past examples.

[1233] Emotion Recognition Engine

[1234] The emotion recognition engine collects and analyzes emotional data from facial expressions, voice, and text input patterns while a user is creating a request for approval. For example, if a user is feeling stressed, the system can recognize that emotion and adjust the way error messages are presented. Additionally, if the emotion recognition engine determines that a decision maker is feeling anxious or uncertain while reviewing past approval results, the system can highlight past success stories and suggest additional reference materials to support the decision maker's decision-making.

[1235] Specific hardware and software

[1236] To implement this system, the following hardware and software are required:

[1237] Hardware: User devices (smartphones, tablets, PCs, etc.), servers, cameras for optical character recognition.

[1238] Software: Natural language processing models (Spacy), optical character recognition software (pytesseract), emotion recognition engines (transformers).

[1239] Examples of concrete examples and prompts

[1240] As an example of a valid use case, consider a factory maintenance request. Here is an example prompt:

[1241] Specific examples

[1242] Input: Image file "maintenance_request.jpg"

[1243] Output: Extracted text: "I would like to request maintenance for Machine A. The budget is 100,000 yen." Suggested correction for typos: "Request -> Check required." Emotion recognition result: "Emotion: Negative, Confidence: 0.85."

[1244] Prompt Sentence Examples

[1245] Extract the text from the image file "maintenance_request.jpg" and check for typos and user sentiment. Also, display the approval results from similar requests in the past.

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

[1247] Step 1:

[1248] The user inputs the details of the approval request into the terminal. The input data includes the project name, purpose, budget amount, required documents, etc. This input data is sent from the terminal to the server.

[1249] Step 2:

[1250] The server checks the received request for typos and grammatical errors using a natural language processing model (Spacy). The input is the text data of the request, and the output is correction suggestions and error messages. The server detects typos and grammatical errors and generates appropriate correction suggestions.

[1251] Step 3:

[1252] Next, the server processes the image of the quotation attached to the request form using optical character recognition software (pytesseract) to extract the amount. The input is the image data of the quotation, and the output is the extracted amount data. The server obtains the amount information as text and compares it with the amount written on the request form.

[1253] Step 4:

[1254] The server compares the amount written in the request form with the amount extracted from the quotation, and generates an error message if there is a discrepancy. The input is the amount data in the request form and the extracted amount data, and the output is an error message. The server detects errors and generates a specific error message.

[1255] Step 5:

[1256] The server uses emotion recognition engines (transformers) to analyze the user's emotional state. The input is facial expression, voice, and text input data while the user is creating the request, and the output is the emotion recognition results. The server evaluates the user's emotional state and recognizes negative emotions such as stress.

[1257] Step 6:

[1258] The server adjusts the presentation of error messages based on the results of the emotion recognition engine. The input is the emotion recognition result, and the output is the adjusted error message. If the user is feeling stressed, the server presents the error message in a gentle, supportive tone.

[1259] Step 7:

[1260] The user checks the error message and corrects any necessary corrections. The input is the error message sent from the server, and the output is the corrected approval request data. The user corrects the approval request based on the error message.

[1261] Step 8:

[1262] The approver inputs the details of a newly received approval document into the terminal. This is sent to the server, which searches a database of past approval documents. The input is the data of the new approval document, and the output is a list of similar past approval documents. The server uses a natural language processing model to search the database and extract similar approval documents.

[1263] Step 9:

[1264] The server presents the approver with a list of similar approval documents from the search results and displays the approval results for each approval document. The input is a list of similar past approval documents, and the output is the display data of the approval results. The server helps the approver make decisions quickly and accurately based on past cases.

[1265] Step 10:

[1266] The emotion recognition engine recognizes the decision maker's emotional state and proposes a course of action if certain conditions are met. The input is the decision maker's facial expression, voice, and text data, and the output is the emotion recognition results and proposal data. If the decision maker has concerns or doubts, the server highlights past success stories and provides additional reference materials.

[1267] Specific actions

[1268] Specific examples

[1269] Input: Image file "maintenance_request.jpg"

[1270] Output: Extracted text: "I would like to request maintenance for Machine A. The budget is 100,000 yen." Suggested correction for typos: "Request -> Check required." Emotion recognition result: "Emotion: Negative, Confidence: 0.85."

[1271] Prompt Sentence Examples

[1272] Extract the text from the image file "maintenance_request.jpg" and check for typos and user sentiment. Also, display the approval results from similar requests in the past.

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

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

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

[1276] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1290] This invention is a system to support the drafter and approver of approval requests, and mainly provides functions for checking for typos, confirming amounts, and referencing past approval request data. This system utilizes AI technology, natural language processing (NLP) and optical character recognition (OCR) technologies to provide an efficient and accurate approval process.

[1291] Proposer Support System

[1292] The user enters the details of the approval request into the terminal. This includes the project name, objectives, budget, and required documents. The terminal then sends this information to the server, where a natural language processing model is used to check for typos and grammatical errors. For example, if the user enters "new product development" but misspells "new parts development," the AI ​​model detects this and generates correction suggestions. Furthermore, the content of the estimate attached to the approval request (e.g., "¥500,000") is extracted using OCR technology and compared with the amount entered in the approval request (e.g., "¥50,000"). If an error is found, the server generates an error message ("Typo detected: 'New parts development' → 'New product development'. Amount input error: '¥50,000' → '¥500,000'") and sends it to the terminal. The user can then review the error message and correct the approval request.

[1293] Decision maker support system

[1294] The decision maker enters the details of a newly received approval document into their terminal. This information is sent to the server, which searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. For example, if five approval documents related to "new product development" have been found in the past, the server obtains the approval results (two approved, three rejected) and displays them on the decision maker's terminal. This allows the decision maker to make quick and accurate decisions based on past examples.

[1295] As a specific example, when a user creates a request for approval for a "new product development budget application," the system checks for typos and omissions and confirms that the amount matches the estimate. The system also allows the approver to refer to the approval results of similar requests in the past, making the process more efficient. In this way, the present invention supports the approval process, improving work efficiency and accuracy.

[1296] The processing flow will be explained below.

[1297] Proposer Support System

[1298] Program processing

[1299] Step 1:

[1300] The user enters the contents of the request form into the terminal.

[1301] The user enters information such as the project name, purpose, budget amount, and required documents into the approval form.

[1302] Step 2:

[1303] The terminal sends the entered approval request details to the server.

[1304] The terminal sends the request data to the server via the API using a POST request.

[1305] Step 3:

[1306] The server uses a natural language processing model to check the approval request for spelling and grammatical errors.

[1307] The server inputs the request text into a natural language processing (NLP) model to detect and point out typos and grammatical errors.

[1308] Step 4:

[1309] The server reads the contents of the quotation attached to the request form.

[1310] The server uses optical character recognition (OCR) technology to extract the amount from the quotation and compare it with the amount in the approval document.

[1311] Step 5:

[1312] The server compares the amount stated in the request with the amount extracted from the quotation.

[1313] The server compares the extracted amount information with the amount information on the request form to confirm that they match.

[1314] Step 6:

[1315] The server generates an error message based on the comparison.

[1316] If the server detects an error, it creates an error message and cleans up the contents.

[1317] Step 7:

[1318] Sends any server-generated error messages to the terminal for display to the user.

[1319] The server returns an error message in JSON format to the terminal, and the terminal displays the error message in the user interface (UI).

[1320] Step 8:

[1321] The user corrects the request according to the error message.

[1322] The user checks the error message displayed on the device, corrects the contents of the approval request, and sends the corrected version to the server again.

[1323] ---

[1324] Decision maker support system

[1325] Program processing

[1326] Step 1:

[1327] The approver enters the contents of the newly received request into the terminal.

[1328] The approver enters the newly received approval information into the approval form. Example: Project name: "New product development" "Budget: ¥500,000"

[1329] Step 2:

[1330] The terminal sends the contents of the request to the server.

[1331] The terminal sends the request data to the server via the API using a POST request.

[1332] Step 3:

[1333] The server searches for similar requests from a database of past requests.

[1334] The server inputs the details of the request (project name, budget, purpose, etc.) into a natural language processing (NLP) model and searches the database.

[1335] Step 4:

[1336] The server extracts similar approval documents from the search results.

[1337] The server filters past requests based on attributes such as amount, project content, and submitting department, and lists the most matching data.

[1338] Step 5:

[1339] The server obtains the approval results of the extracted past approval documents.

[1340] The server obtains the decision results (approval, rejection, etc.) of the extracted proposals and organizes them along with any error messages.

[1341] Step 6:

[1342] The server sends the approval status of past approval requests to the terminal and presents it to the approver.

[1343] The server returns the approval status in JSON format to the terminal, and the terminal displays the information on the UI.

[1344] Example 1

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

[1346] In the conventional approval process, the proposer had to manually check the approval document for typos and grammatical errors, and also manually check for discrepancies between the amount listed on the estimate and the amount listed on the approval document. This made it prone to errors and increased the likelihood of delays in the approval process. Furthermore, the approver had to manually search past approval document data and refer to the approval results of similar approval documents, making it difficult to make efficient decisions. A solution to these problems was needed.

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

[1348] In this invention, the server includes: a means for a user to input the contents of a request form into a terminal and the terminal transmits this information to the server; a means including a natural language processing model for detecting typographical errors; optical character recognition means for extracting the amount stated in the request form from an estimate; means for comparing the amount stated in the request form with the amount extracted from the estimate; means for generating an error message based on the comparison result; and means for presenting the error message to the user. This allows the drafter to automatically detect and correct typographical errors and discrepancies in the amount in the request form, thereby realizing an efficient and error-free request process. The server also includes a means including a natural language processing model for searching past request form data; means for extracting similar request forms from the search results; and means for presenting the approval results of the extracted request forms. This allows the decision maker to quickly refer to data on similar past request forms and make decisions efficiently.

[1349] A "user" is someone who inputs the contents of a request form and checks error messages from the system.

[1350] A "terminal" is an electronic device that a user uses to input the contents of a request form and exchange information with a server.

[1351] A "server" is a central processing unit that receives information sent by a user, processes it, and returns the results to the terminal.

[1352] A "requisition form" is a document that lists the project name, purpose, budget amount, and required documents, and is used for approval procedures within a company.

[1353] A "natural language processing model" is a machine learning model that analyzes text data to detect typos and grammatical errors.

[1354] "Typographical errors" refer to typos or input errors contained in the text content of a request form.

[1355] "Optical character recognition" is a technology that extracts character information from images or documents such as PDF files.

[1356] An "quote" is a document that lists the budget amount and detailed expenses, and is attached to a request form.

[1357] The "comparison method" is a method for comparing the amount stated in the request form with the amount extracted from the estimate to determine whether they match or not.

[1358] An "error message" is information that notifies the user of problems with the request form, such as typos or mismatched amounts.

[1359] The "search method" is a technology for searching past approval request data from a database.

[1360] A "similar request form" is a past request form whose content is similar to that of the current request form.

[1361] "Decision result" refers to the result of approval or rejection of a past request for approval.

[1362] This invention is a system to support the drafter and approver of approval requests, primarily by checking for typos, confirming amounts, and providing functions for referencing past approval request data. The system utilizes AI technology, natural language processing (NLP) and optical character recognition (OCR) technologies, to provide an efficient and accurate approval process.

[1363] First, the user inputs the details of the request into the device. This information includes the project name, purpose, budget, and required documents. The device then sends this information to the server, which uses a natural language processing model (e.g., BERT or GPT-3) to check for typos and grammatical errors.

[1364] For example, if a user accidentally types "new product development" instead of "new parts development," the AI ​​model detects the error and generates the correct spelling, "new product development," as a correction suggestion. Also, when a user uploads a quote (e.g., a PDF file) attached to a request form to their device, the quote is sent from the device to the server. The server uses OCR technology (e.g., Tesseract OCR) to extract the amount information from the quote. The server compares the extracted amount (e.g., "¥500,000") with the amount written in the request form (e.g., "¥50,000") and generates a correction suggestion if there is an error.

[1365] The server compiles these correction suggestions and generates an error message (e.g., "Typo detected: 'New parts development' → 'New product development'. Amount input error: '￥50,000' → '￥500,000'.") and sends it to the terminal. The user can check the error message and correct the approval request.

[1366] Next, the approver enters the details of the newly received approval document into their terminal and sends it to the server. The server uses a natural language processing model to search a database of past approval documents, searching for past approval documents with similar amounts, project details, and submitting departments. For example, if five past approval documents related to "new product development" are found, the server obtains the approval results (two approved, three rejected) and displays them on the approver's terminal. This enables the approver to make quick and accurate decisions based on past examples.

[1367] An example of a specific prompt is:

[1368] 1. Typo detection: "Detect typos in this text: New parts development"

[1369] 2. OCR processing of quote: "Please extract the amount from this PDF file"

[1370] 3. Search for similar approval documents: "Search for past approval documents similar to the following: Project name = New product development, Budget = ¥500,000"

[1371] This system allows users and decision makers to work efficiently and accurately during the approval process, minimizing errors.

[1372] In this way, the present invention is a system that supports the process of drafting and approving requests, and aims to improve the efficiency and accuracy of business operations.

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

[1374] Proposer Support System

[1375] Step 1:

[1376] The user enters the details of the approval request.

[1377] Input: Project name, purpose, budget amount, required documents, and other information on the approval request

[1378] Output: Input information is saved to the terminal

[1379] The user enters the project name (e.g., "New product development"), purpose (e.g., "Market expansion"), budget amount (e.g., "500,000 yen"), and required documents (e.g., "Quote") into a form on the device. The device converts the input data into JSON format and sends it to the server.

[1380] Step 2:

[1381] The device sends the input information to the server

[1382] Input: Approval information entered by the user on the device (JSON format)

[1383] Output: Approval information sent to the server

[1384] The device converts the user's input into JSON format and sends it to the server. This information includes the project name, purpose, budget, and required documents.

[1385] Step 3:

[1386] The server uses natural language processing models to detect spelling errors

[1387] Input: JSON formatted approval document information received on the server

[1388] Output: Detected spelling and grammatical errors (correction suggestions)

[1389] The server passes the received JSON data to a natural language processing model (e.g., BERT or GPT-3), which detects typos (e.g., "new parts development" → "new product development") and grammatical errors in the sentence and returns correction suggestions.

[1390] Step 4:

[1391] User uploads a quote

[1392] Input: Digital quotation in PDF format

[1393] Output: Quote file saved on the device

[1394] The user uploads a quote (e.g., PDF format) to the device, which saves the quote and sends it to the server for further processing.

[1395] Step 5:

[1396] The device sends the estimate to the server

[1397] Input: Quote file uploaded by user

[1398] Output: Quote file sent to the server

[1399] The terminal sends the saved quotation file to the server.

[1400] Step 6:

[1401] The server uses OCR technology to extract the amount from the quote.

[1402] Input: Quotation file that arrived on the server

[1403] Output: Extracted amount data (e.g., "￥500,000")

[1404] The server uses OCR technology (e.g., Tesseract OCR) to extract the amount from the quote. For example, it extracts "￥500,000" as the amount in the quote.

[1405] Step 7:

[1406] The server compares the amount in the request form with the amount in the quotation

[1407] Input: Amount stated in the request and amount extracted from the estimate

[1408] Output: Amount match / mismatch detection result (correction suggestions if there are differences)

[1409] The server compares the extracted amount (e.g., "500,000 yen") with the amount stated in the approval request (e.g., "50,000 yen"), and if there is an error, generates a correction suggestion (e.g., "500,000 yen").

[1410] Step 8:

[1411] The server generates an error message

[1412] Input: Detected results of spelling errors, grammatical errors, and amount matches / mismatches

[1413] Output: Generated error message (e.g., "Typo detected: 'New parts development' → 'New product development'. Amount input error: '￥50,000' → '￥500,000'.")

[1414] The server generates error messages based on typos, grammar errors, and matched / mismatched amounts.

[1415] Step 9:

[1416] The server sends an error message to the terminal.

[1417] Input: The generated error message

[1418] Output: Error message sent to terminal

[1419] The server generates an error message and sends it to the terminal, allowing the user to review it and correct the contents of the request form.

[1420] Decision maker support system

[1421] Step 1:

[1422] The approver submits a new approval document to the server.

[1423] Input: The content of the new approval request entered by the approver into the terminal

[1424] Output: Approval information sent to the server

[1425] The decision maker enters a new request form on the terminal and sends it to the server.

[1426] Step 2:

[1427] The server searches the approval document database

[1428] Input: Contents of new approval request

[1429] Output: List of similar past approval documents found

[1430] The server searches a database of past approval requests using a natural language processing model (e.g., BERT or GPT-3) to extract approval requests with similar project names, budget amounts, and submitting departments.

[1431] Step 3:

[1432] The server obtains the approval result and displays it on the terminal.

[1433] Input: List of similar past approval documents

[1434] Output: Approval results of similar approval documents displayed on the terminal (e.g., 5 approval documents related to "new product development" were found, of which 2 were approved and 3 were rejected)

[1435] The server lists the search results and sends them to the approver's device along with past approval decisions. The approver makes a decision on the current approval decision, referring to the approval decisions of similar past approval decisions.

[1436] In this way, systems that support users and decision makers can streamline and improve the accuracy of the request document creation and approval process.

[1437] (Application example 1)

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

[1439] The traditional approval process required a lot of manual work, and there were frequent problems with typos and discrepancies in amounts. Searching for similar approval documents in the past was also inefficient, making it difficult to make quick decisions. While there is a particular need for more efficient approval process in factories, the lack of systems to automate current procedures has hindered improvements in efficiency and accuracy.

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

[1441] In this invention, the server includes: means for detecting typos and omissions, means for including a natural language processing model, means for including optical character recognition technology for extracting the amount stated in the request form from the estimate, means for comparing the amount stated in the request form with the amount extracted from the estimate, means for including a generative AI model for generating an error message based on the comparison result, means for generating a prompt sentence for presenting the error message to the user, means for scanning the request form and extracting text information, means for including a natural language processing model for searching past request form data, means for extracting similar request forms from the search results, and means for presenting the approval results of the extracted request form. This enables the efficiency and accuracy of the request form creation and approval process to be improved.

[1442] A "natural language processing model for detecting typos and misspellings" is an algorithm that automatically detects spelling and grammatical errors in a sentence and suggests corrections.

[1443] "Optical character recognition technology for extracting amounts from estimates" is a technology that extracts text information, particularly amounts, as digital data from images of estimates read by a scanner or camera.

[1444] A "generative AI model that generates error messages" is an artificial intelligence model that automatically generates error messages based on detected error information such as typos or mismatched amounts.

[1445] The "means for generating a prompt sentence" is a means for automatically generating an instruction sentence or a confirmation message to be presented to the user.

[1446] "Means of scanning approval documents and extracting text information" refers to technology for digitizing physical approval documents and obtaining text data from them.

[1447] The "natural language processing model for searching past approval request data" is an algorithm for analyzing a database of previously submitted approval requests and searching for and retrieving related information.

[1448] The "means for extracting similar approval documents" refers to a means for identifying and extracting approval documents whose contents are similar to the current approval document from a database of past approval documents.

[1449] The "means for presenting the decision results" is a means for obtaining the decision results of past approval requests and providing them to the user as information.

[1450] To implement this invention, a system is constructed that supports the process from receipt of approval documents to approval. Specifically, this system uses the following hardware and software:

[1451] Hardware:

[1452] Factory robot: Used for scanning approval documents and user interface

[1453] Scanner: Used to digitize physical documents and estimates

[1454] Server: processes and stores data

[1455] software:

[1456] OCR engine (Tesseract): Extracts text information from scanned documents

[1457] Natural language processing library (spaCy): used for text analysis, typo detection, and historical data search

[1458] Database (PostgreSQL): Store and search past approval documents

[1459] Program operation description:

[1460] 1. Scanning the approval document:

[1461] The terminal (factory robot) uses a scanner to read the approval document submitted by the user. The scanned image data is sent to the server, which then analyzes it with an OCR engine (Tesseract) and extracts the text data.

[1462] 2. Check for typos:

[1463] The extracted text data is analyzed on the server using a natural language processing library (spaCy). This analysis detects typos and omissions in the request form. The detection results are input into a generative AI model, which generates an error message along with suggested corrections.

[1464] 3. Amount Verification:

[1465] The amount written on the request form and the amount written on the quotation are extracted using OCR technology and automatically compared on the server. If they do not match, an error message is generated by the generative AI model.

[1466] 4. Searching historical data:

[1467] The server uses a natural language processing library to search a database of past approval documents (PostgreSQL) and extracts cases similar to the current approval document, allowing the approver to refer to past approval results.

[1468] 5. User Feedback:

[1469] Generated error messages and approval results for past approval requests are displayed as prompts on the terminal (factory robot) display so that the user can check them.

[1470] Examples:

[1471] For example, suppose a factory's A-Robot receives a new approval document, which is a "budget request for new product development." The robot first scans the document and extracts text information using an OCR engine. The server receives the text data and analyzes it using a natural language processing library (spaCy) to check for typos. The quotation is also scanned in the same way, and the amount is extracted. If the amount on the approval document and the quotation do not match, for example, if ¥500,000 is entered as ¥50,000, the generative AI model generates an error message.

[1472] Furthermore, the server searches for similar past requests for approval, and if, for example, there have been three similar "new product development" requests in the past, the approval results (e.g., two approved, one rejected) are displayed on the robot's screen.

[1473] Example prompt sentence:

[1474] The "New Product Development Budget Request" approval form has been scanned. Please check for typos and confirm that the amount is correct: 500,000 yen. Search for similar approval forms in the past and view the approval results.

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

[1476] Step 1:

[1477] When a user submits a request for approval, the terminal (factory robot) scans the request and sends the scanned image data to an OCR engine (Tesseract) to extract text information.

[1478] Input: Scanned image data of the approval document

[1479] Output: Extracted text data

[1480] Step 2:

[1481] The server receives the extracted text data and uses a natural language processing library (spaCy) to detect typos and omissions, and the detection results also include suggested corrections.

[1482] Input: Extracted text data

[1483] Output: Misspelling detection results (including correction suggestions)

[1484] Step 3:

[1485] The user also scans the quote using a scanner and sends the image data to the OCR engine, which extracts the quote amount.

[1486] Input: Scanned image data of quote

[1487] Output: Amount data extracted from the quotation

[1488] Step 4:

[1489] The server compares the amount data in the request and the quotation, and if the amounts do not match, the generative AI model automatically generates an error message.

[1490] Input: Amount data extracted from the approval document, amount data extracted from the quotation

[1491] Output: Error message

[1492] Step 5:

[1493] The server searches a database of past approval requests and uses a natural language processing library to extract requests similar to the current one.

[1494] Input: Text data of the approval request

[1495] Output: Similar past approval documents

[1496] Step 6:

[1497] The server generates a message showing the past approval results based on the extracted past approval request data. This message including the approval results is sent to the terminal (factory robot) and displayed to the user.

[1498] Input: Similar past approval documents data

[1499] Output: Past approval results and suggested messages

[1500] Step 7:

[1501] The user checks the error messages and past approval results displayed on the factory robot's display and makes corrections to the approval document as necessary.

[1502] Input: Error messages, past approval results

[1503] Output: Modified decision (if necessary)

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

[1505] This invention is a system for supporting approval process initiators and approvers, and improves the process more effectively by combining functions such as checking for typos, confirming amounts, and referencing past approval process data with an emotion engine that recognizes user emotions. This system utilizes AI technology, natural language processing (NLP), optical character recognition (OCR), and emotion recognition technology to provide an efficient and accurate approval process.

[1506] Proposer Support System

[1507] The user enters the details of the approval request into the terminal. This includes the project name, objectives, budget, and required documents. The terminal then sends this information to the server, where a natural language processing model is used to check for typos and grammatical errors. For example, if the user enters "new product development" and then erroneously enters "newly manufactured parts development," the AI ​​model detects this and generates correction suggestions. Furthermore, the content of the estimate attached to the approval request (e.g., "¥500,000") is extracted using OCR technology and compared with the amount entered in the approval request (e.g., "¥50,000"). If an error is found, the server generates an error message ("Typo detected: 'newly manufactured parts development' → 'new product development'. Amount input error: '¥50,000' → '¥500,000'") and sends it to the terminal. The user can then review the error message and correct the approval request.

[1508] Furthermore, the system has an emotion engine to recognize the user's emotions. The emotion engine collects and analyzes emotional data from facial expressions, voice, and text input patterns while the user is creating the request form. For example, if the user is feeling stressed, the system can recognize that emotion and adjust the way error messages are presented. Specifically, if the emotion engine determines that the user is feeling stressed, the system will display error messages in a gentle, supportive tone.

[1509] Decision maker support system

[1510] The decision maker enters the details of a newly received approval document into their terminal. This information is sent to the server, which searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. For example, if five approval documents related to "new product development" have been found in the past, the server obtains the approval results (two approved, three rejected) and displays them on the decision maker's terminal. This allows the decision maker to make quick and accurate decisions based on past examples.

[1511] Furthermore, the emotion engine recognizes the decision maker's emotional state and suggests a course of action if certain conditions are met. For example, if the emotion engine determines that a decision maker is feeling anxious or uncertain while reviewing past decision results, the system will highlight past success stories and suggest additional reference materials to support the decision maker's decision-making.

[1512] As a specific example, when a user creates a request for approval for a "new product development budget application," the system checks for typos and verifies that the amount matches the estimate. Furthermore, the system recognizes the user's emotions and displays a supportive error message if the user is feeling stressed. Furthermore, if the decision maker is feeling anxious, the system highlights specific success stories while referring to past approval results for similar applications. In this way, the present invention supports the entire process of request proposal and approval through emotion recognition, improving work efficiency and accuracy.

[1513] The processing flow will be explained below.

[1514] Proposer Support System

[1515] Program processing

[1516] Step 1:

[1517] The user enters the contents of the request form into the terminal.

[1518] The user enters information such as the project name, purpose, budget amount, and required documents into the approval form.

[1519] Step 2:

[1520] The terminal sends the entered approval request details to the server.

[1521] The terminal sends the request data to the server via the API using a POST request.

[1522] Step 3:

[1523] The server uses a natural language processing model to check the approval request for spelling and grammatical errors.

[1524] The server inputs the request text into a natural language processing (NLP) model to detect and point out typos and grammatical errors.

[1525] Step 4:

[1526] The server reads the contents of the quotation attached to the request form.

[1527] The server uses optical character recognition (OCR) technology to extract the amount from the quotation and compare it with the amount in the approval document.

[1528] Step 5:

[1529] The server compares the amount stated in the request with the amount extracted from the quotation.

[1530] The server compares the extracted amount information with the amount information on the request form to confirm that they match.

[1531] Step 6:

[1532] The server generates an error message based on the comparison.

[1533] If the server detects an error, it creates an error message and cleans up the contents.

[1534] Step 7:

[1535] Sends any server-generated error messages to the terminal for display to the user.

[1536] The server returns an error message in JSON format to the terminal, and the terminal displays the error message in the user interface (UI).

[1537] Step 8:

[1538] The user corrects the request according to the error message.

[1539] The user checks the error message displayed on the device, corrects the contents of the approval request, and sends the corrected version to the server again.

[1540] Step 9:

[1541] The emotion engine analyzes facial expressions and voice data as the user types.

[1542] The server uses an emotion engine to analyze the user's emotional state and processes the results.

[1543] Step 10:

[1544] The server adjusts how error messages are presented based on the emotion data.

[1545] The server takes appropriate considerations into account the user's emotional state and changes the tone of the error message.

[1546] ---

[1547] Decision maker support system

[1548] Program processing

[1549] Step 1:

[1550] The approver enters the contents of the newly received request into the terminal.

[1551] The approver enters the newly received approval information into the approval form. Example: Project name: "New product development" "Budget: ¥500,000"

[1552] Step 2:

[1553] The terminal sends the contents of the request to the server.

[1554] The terminal sends the request data to the server via the API using a POST request.

[1555] Step 3:

[1556] The server searches for similar requests from a database of past requests.

[1557] The server inputs the details of the request (project name, budget, purpose, etc.) into a natural language processing (NLP) model and searches the database.

[1558] Step 4:

[1559] The server extracts similar approval documents from the search results.

[1560] The server filters past requests based on attributes such as amount, project content, and submitting department, and lists the most matching data.

[1561] Step 5:

[1562] The server obtains the approval results of the extracted past approval documents.

[1563] The server obtains the decision results (approval, rejection, etc.) of the extracted proposals and organizes them along with any error messages.

[1564] Step 6:

[1565] The server sends the approval status of past approval requests to the terminal and presents it to the approver.

[1566] The server returns the approval status in JSON format to the terminal, and the terminal displays the information on the UI.

[1567] Step 7:

[1568] The emotion engine analyzes the emotional state of the decision maker.

[1569] The server uses an emotion engine to analyze the decision maker's emotional state and processes the results.

[1570] Step 8:

[1571] The server proposes a response policy based on the emotion data.

[1572] The server suggests the most appropriate action depending on the decision maker's emotional state, for example by displaying information that emphasizes past success stories.

[1573] ---

[1574] These processing steps provide efficient and accurate support to both the request initiator and the approver. By incorporating an emotion engine, more natural interactions can be achieved that take into consideration the user's emotions, further improving the efficiency and accuracy of work.

[1575] Example 2

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

[1577] The current approval process requires a lot of manual work, which is time-consuming and labor-intensive. It's also prone to typos and input errors, which can delay approval. Furthermore, there's a lack of support that takes into account the feelings of users and decision makers, which can lead to increased stress and anxiety. This creates a need for greater efficiency and accuracy in the process.

[1578] 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 a means including a natural language processing model for detecting typographical errors, a means for extracting numerical information described in the approval request form from the document, and a means for comparing the numerical information described in the approval request form with the numerical information extracted from the document. This makes it possible to automatically detect typographical errors and discrepancies in amounts, thereby reducing the manual work of the user.

[1579] Furthermore, in this invention, the server includes means for generating an error message based on the comparison result, means for presenting the error message to the user, and means including an emotion recognition engine for recognizing the user's emotion and adjusting the way the error message is presented, thereby enabling appropriate support for the user and enabling them to check and correct the error message while reducing stress.

[1580] The server also includes a means including a natural language processing model for searching past approval request data, a means for extracting similar approval requests from the search results, a means for presenting the decision results of the extracted approval requests, and a means including an emotion recognition engine for recognizing the emotions of the decision maker and making suggestions to support the decision-making. This allows the decision maker to make decisions quickly and accurately based on past cases and receive appropriate support.

[1581] A "natural language processing model for detecting typos" is an artificial intelligence technique used to analyze text data and automatically detect typos, spelling errors, and grammatical errors.

[1582] "Means for extracting numerical information contained in a request form from the document" refers to a technology for accurately extracting numerical information such as amounts from attached documents (such as estimates).

[1583] "Means for comparing the numerical information entered in the request form with the numerical information extracted from the document" refers to a technology for comparing the numerical information entered in the request form with the numerical information extracted from the document and checking for matches or mismatches.

[1584] The "means for generating an error message" is a technique for creating a message to notify the user when a typographical error or a mismatch in numerical information is detected.

[1585] "Means for presenting an error message to the user" refers to a technique for displaying the generated error message on the user's terminal screen and prompting the user to correct the error.

[1586] An "emotion recognition engine" is a technology that analyzes the facial expressions, voice, and text input patterns of users and decision makers to recognize emotions such as stress and anxiety.

[1587] "Means for recognizing emotions and adjusting the presentation method of error messages" refers to a technology that adjusts the display method and tone of error messages based on the user's emotional state recognized by an emotion recognition engine.

[1588] The "natural language processing model for searching past approval documents" is an artificial intelligence technology used to search a database of past approval documents and identify similar approval documents.

[1589] "Means for extracting similar approval documents" refers to a technique for selecting approval documents with similar content from past approval documents.

[1590] The "means for presenting the decision results of the extracted request documents" is a technology for displaying the decision results (such as approval or rejection) of the extracted past request documents to the user or authorizer.

[1591] The "emotion recognition engine that makes suggestions to support decision-making" is a technology that recognizes the emotional state of the decision maker and supports the decision-making process by presenting past success stories and additional materials.

[1592] This invention is a system for supporting approval request drafters and approvers, and improves the process more effectively by combining functions for checking for typos, confirming amounts, and referencing past approval request data with an emotion recognition engine that recognizes the user's emotions. This system utilizes AI technology, natural language processing (NLP), optical character recognition (OCR), and emotion recognition technology to provide an efficient and accurate approval request process.

[1593] System Configuration

[1594] Proposer Support System

[1595] The user enters the details of the approval request into the terminal. This includes the project name, purpose, budget, and required documents. The terminal sends this information to the server, which uses a natural language processing model to check for typos and grammatical errors. For example, if the user enters "new product development" and then misspells "new parts development," the server will detect this and generate correction suggestions.

[1596] Next, the content of the quotation attached to the request form (for example, "¥500,000") is extracted using OCR technology and compared with the amount entered in the request form (for example, "¥50,000"). If there is an error, the server generates an error message and sends it to the terminal, stating, "Typo detected: 'New parts development' → 'New product development'. Amount input error: '¥50,000' → '¥500,000'." The user can then check the error message and correct the request form.

[1597] Additionally, the system is equipped with an emotion recognition engine. The emotion recognition engine collects and analyzes emotional data from facial expressions, voice, and text input patterns while the user is creating the request form. For example, if the user is feeling stressed, the system recognizes that emotion and adjusts the way error messages are presented. Specifically, if the emotion recognition engine determines that the user is feeling stressed, the system displays error messages in a gentle, supportive tone.

[1598] Decision maker support system

[1599] The decision maker enters the details of a newly received approval document into their terminal. This information is sent to the server, which searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. For example, if five approval documents related to "new product development" have been found in the past, the server obtains the approval results (two approved, three rejected) and displays them on the decision maker's terminal. This allows the decision maker to make quick and accurate decisions based on past examples.

[1600] Furthermore, the emotion recognition engine recognizes the decision maker's emotional state and suggests a course of action if certain conditions are met. For example, if the emotion recognition engine determines that the decision maker is feeling anxious or uncertain while reviewing past decision results, the system will highlight past success stories and suggest providing additional reference materials.

[1601] Examples and prompts

[1602] Specific examples

[1603] 1. Check for spelling errors in your input

[1604] A user creates a request for approval for a "new product development budget" and mistakenly types "new part development." The server detects this and suggests correcting it to "new product development."

[1605] 2. Check the amount

[1606] If a user enters "¥50,000" in a request form and the attached estimate states "¥500,000," the server will detect this discrepancy and prompt the user to change "¥50,000" to "¥500,000."

[1607] 3. Emotion-based error message display

[1608] If the user is stressed, an emotion recognition engine will detect this and display a gentle error message.

[1609] 4. Reference to past approval documents

[1610] When a decision maker approves a "new product development budget request," they search a database of past approval requests and report that two similar requests have been approved and three have been rejected.

[1611] Prompt Sentence Examples

[1612] 1. "Please check the new product development approval documents for typos and inconsistencies in amounts."

[1613] 2. "Please display error messages in a gentle tone if the user is feeling stressed while creating a request."

[1614] 3. "Search for similar past approval requests and their approval results and display a list."

[1615] 4. "If the decision maker is feeling unsure, highlight past success stories."

[1616] In this way, the system improves the efficiency of the approval process and provides user support through specific implementation examples and prompt statements.

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

[1618] Step 1:

[1619] The user inputs the details of the approval request into the terminal. The input details include the project name, purpose, budget amount, required documents, etc. For example, the user inputs the project name "New product development," the purpose "To improve sales," the budget amount "500,000 yen," and uploads the quotation file. This input information becomes the basic data for the next step.

[1620] Step 2:

[1621] The terminal sends the entered information to the server. Data such as the project name, purpose, budget amount, and attached estimate are transferred to the server via the network. After the server receives this information, it prepares it for the next process.

[1622] Step 3:

[1623] The server uses a natural language processing model to check for typos and grammatical errors. The server inputs the received text data into a natural language processing (NLP) model to detect typos and grammatical errors. For example, if "new parts development" is input incorrectly, the server generates a suggestion to correct this to "new product development." This suggestion is sent to the next step.

[1624] Step 4:

[1625] The server uses OCR technology to extract the amount from the quote and compare it with the amount in the approval request. The server inputs the attached quote file into the OCR module and obtains the extracted amount (e.g., "500,000 yen"). This is then compared with the amount entered in the approval request (e.g., "50,000 yen") to confirm any discrepancies. The result of this comparison becomes the data to proceed to the next step.

[1626] Step 5:

[1627] The server generates an error message and sends it to the terminal. The server generates an error message based on the results of the typo detection and the discrepancy in the amount. For example, an error message such as "Typo detected: 'New parts development' → 'New product development'. Amount input error: '￥50,000' → '￥500,000'" is generated and sent to the terminal. The user confirms this error message.

[1628] Step 6:

[1629] The user checks the error message and corrects the approval request. The user checks the error message on the terminal and makes the necessary corrections. For example, the project name is changed to "New Product Development" and the budget amount is changed to "500,000 yen." This corrected information is sent back to the server and proceeds to the next process.

[1630] Step 7:

[1631] The emotion recognition engine recognizes the user's emotions and generates an appropriate error message. The server uses the emotion recognition engine to collect and analyze emotional data from the user's facial expressions, voice, and text input patterns. For example, if the user is feeling stressed, the system will recognize this and display an error message in a gentle tone. For example, it will display, "Thank you for your hard work. We understand that you are probably feeling stressed, but we have corrected the typo in 'New Parts Development' to 'New Product Development'. You're almost there, keep trying!"

[1632] (Application example 2)

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

[1634] Conventional approval systems lack sufficient means for detecting typos and confirming amounts, and do not provide error messages or decision-making support that take into account the emotional state of the user or approver. Therefore, there is a need to improve the efficiency and accuracy of the approval process. In particular, there is a need for a method to reduce unnecessary rework caused by typos and incorrect amounts, as well as user stress. Furthermore, in factory operations, there is a need to streamline the process of reviewing numerous work instructions and maintenance requests.

[1635] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means including a natural language processing model for detecting typographical errors, means for extracting the amount stated in the request form from the estimate, means for comparing the amount stated in the request form with the amount extracted from the estimate, means including an emotion recognition engine for recognizing the user's emotional state, means for adjusting an error message based on the results of the emotion recognition engine, means for presenting the error message to the user, means including a natural language processing model for searching past request form data, means for extracting similar request forms from the search results, means for presenting the approval result of the extracted request form, means including an emotion recognition engine for recognizing the emotional state of the approver, and means for providing additional reference materials based on the results of the emotion recognition engine. This enables efficient detection and correction of typographical errors and incorrect amounts, and enables appropriate feedback and decision-making support that takes into account the emotional state of the user and the approver.

[1636] "Typographical errors" refers to spelling or typing errors contained in a document.

[1637] "Natural language processing model" refers to a machine learning or AI algorithm designed to understand, generate, or translate natural language.

[1638] "Monetary value extraction" refers to the process of identifying and extracting numerical information contained within a document.

[1639] An "emotion recognition engine" refers to technology that collects and analyzes emotional data from a user's facial expressions, voice, and text input patterns.

[1640] "Error Message" means a message that notifies the user about a problem or error detected by the system.

[1641] "Search Results" means the results obtained from a database or source through a search process.

[1642] "Emotional state" refers to a user's emotional state at a particular point in time.

[1643] "Similar approval documents" refers to past approval document data that has similar content to the current approval document.

[1644] "Decision result" refers to the final approval or rejection of the request.

[1645] "Feedback" refers to the reaction or information that a system provides to a user.

[1646] "Decision support" refers to processes or systems that provide information and tools to help users or decision makers make the best decisions.

[1647] This invention is a system for supporting approval process initiators and approvers, and it improves the process more effectively by combining functions such as checking for typos, confirming amounts, and referencing past approval process data with an emotion engine that recognizes user emotions. This system utilizes AI technology, natural language processing (NLP), optical character recognition (OCR), and emotion recognition technology to provide an efficient and accurate approval process.

[1648] Proposer Support System

[1649] When the drafter enters the contents of the request form into the terminal, a natural language processing model is used to detect typos. The terminal then sends this information to the server, which uses the natural language processing model to check the document for typos and grammatical errors. Additionally, OCR technology is used to extract the amount from the estimate attached to the request form and compare it with the amount entered in the request form. If there is an error, the server generates an error message and sends it to the terminal, allowing the user to review the error message and correct the request form.

[1650] Decision maker support system

[1651] The decision maker enters the details of a newly received approval document into a terminal. This information is sent to a server, which then searches a database of past approval documents. A natural language processing model is used to search for past approval documents with similar amounts, project details, and submitting departments, and a list of similar approval documents is extracted. This allows the decision maker to make decisions quickly and accurately based on past examples.

[1652] Emotion Recognition Engine

[1653] The emotion recognition engine collects and analyzes emotional data from facial expressions, voice, and text input patterns while a user is creating a request for approval. For example, if a user is feeling stressed, the system can recognize that emotion and adjust the way error messages are presented. Additionally, if the emotion recognition engine determines that a decision maker is feeling anxious or uncertain while reviewing past approval results, the system can highlight past success stories and suggest additional reference materials to support the decision maker's decision-making.

[1654] Specific hardware and software

[1655] To implement this system, the following hardware and software are required:

[1656] Hardware: User devices (smartphones, tablets, PCs, etc.), servers, cameras for optical character recognition.

[1657] Software: Natural language processing models (Spacy), optical character recognition software (pytesseract), emotion recognition engines (transformers).

[1658] Examples of concrete examples and prompts

[1659] As an example of a valid use case, consider a factory maintenance request. Here is an example prompt:

[1660] Specific examples

[1661] Input: Image file "maintenance_request.jpg"

[1662] Output: Extracted text: "I would like to request maintenance for Machine A. The budget is 100,000 yen." Suggested correction for typos: "Request -> Check required." Emotion recognition result: "Emotion: Negative, Confidence: 0.85."

[1663] Prompt Sentence Examples

[1664] Extract the text from the image file "maintenance_request.jpg" and check for typos and user sentiment. Also, display the approval results from similar requests in the past.

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

[1666] Step 1:

[1667] The user inputs the details of the approval request into the terminal. The input data includes the project name, purpose, budget amount, required documents, etc. This input data is sent from the terminal to the server.

[1668] Step 2:

[1669] The server checks the received request for typos and grammatical errors using a natural language processing model (Spacy). The input is the text data of the request, and the output is correction suggestions and error messages. The server detects typos and grammatical errors and generates appropriate correction suggestions.

[1670] Step 3:

[1671] Next, the server processes the image of the quotation attached to the request form using optical character recognition software (pytesseract) to extract the amount. The input is the image data of the quotation, and the output is the extracted amount data. The server obtains the amount information as text and compares it with the amount written on the request form.

[1672] Step 4:

[1673] The server compares the amount written in the request form with the amount extracted from the quotation, and generates an error message if there is a discrepancy. The input is the amount data in the request form and the extracted amount data, and the output is an error message. The server detects errors and generates a specific error message.

[1674] Step 5:

[1675] The server uses emotion recognition engines (transformers) to analyze the user's emotional state. The input is facial expression, voice, and text input data while the user is creating the request, and the output is the emotion recognition results. The server evaluates the user's emotional state and recognizes negative emotions such as stress.

[1676] Step 6:

[1677] The server adjusts the presentation of error messages based on the results of the emotion recognition engine. The input is the emotion recognition result, and the output is the adjusted error message. If the user is feeling stressed, the server presents the error message in a gentle, supportive tone.

[1678] Step 7:

[1679] The user checks the error message and corrects any necessary corrections. The input is the error message sent from the server, and the output is the corrected approval request data. The user corrects the approval request based on the error message.

[1680] Step 8:

[1681] The approver inputs the details of a newly received approval document into the terminal. This is sent to the server, which searches a database of past approval documents. The input is the data of the new approval document, and the output is a list of similar past approval documents. The server uses a natural language processing model to search the database and extract similar approval documents.

[1682] Step 9:

[1683] The server presents the approver with a list of similar approval documents from the search results and displays the approval results for each approval document. The input is a list of similar past approval documents, and the output is the display data of the approval results. The server helps the approver make decisions quickly and accurately based on past cases.

[1684] Step 10:

[1685] The emotion recognition engine recognizes the decision maker's emotional state and proposes a course of action if certain conditions are met. The input is the decision maker's facial expression, voice, and text data, and the output is the emotion recognition results and proposal data. If the decision maker has concerns or doubts, the server highlights past success stories and provides additional reference materials.

[1686] Specific actions

[1687] Specific examples

[1688] Input: Image file "maintenance_request.jpg"

[1689] Output: Extracted text: "I would like to request maintenance for Machine A. The budget is 100,000 yen." Suggested correction for typos: "Request -> Check required." Emotion recognition result: "Emotion: Negative, Confidence: 0.85."

[1690] Prompt Sentence Examples

[1691] Extract the text from the image file "maintenance_request.jpg" and check for typos and user sentiment. Also, display the approval results from similar requests in the past.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[1713] The following is further disclosed regarding the above embodiment.

[1714] (Claim 1)

[1715] means including a natural language processing model for detecting typos; and

[1716] A means for extracting the amount stated in the request form from the estimate,

[1717] A means for comparing the amount stated in the request form with the amount extracted from the estimate;

[1718] means for generating an error message based on the comparison result;

[1719] means for presenting said error message to a user;

[1720] A system including:

[1721] (Claim 2)

[1722] The system according to claim 1, further comprising a means for transmitting the contents of the request form and receiving the results after the contents have been checked by the typographical error detection means and the amount extraction means.

[1723] (Claim 3)

[1724] A means including a natural language processing model for searching past approval request data;

[1725] A means of extracting similar approval documents from the search results,

[1726] A means for presenting the decision result of the extracted request form;

[1727] 10. The system of claim 1, comprising:

[1728] (Claim 4)

[1729] 10. The system of claim 1, further comprising an automatic correction means for performing said correction function.

[1730] (Claim 5)

[1731] 10. The system of claim 1, further comprising a terminal including an interface that displays the error message to a user.

[1732]

[1733] "Example 1"

[1734] (Claim 1)

[1735] A means for a user to input the contents of the request document into a terminal, and the terminal transmits this information to a server;

[1736] means including a natural language processing model for detecting typos; and

[1737] an optical character recognition means for extracting the amount stated in the request form from the quotation;

[1738] A means for comparing the amount stated in the request form with the amount extracted from the estimate;

[1739] means for generating an error message based on the comparison;

[1740] means for presenting an error message to a user;

[1741] A system including:

[1742] (Claim 2)

[1743] The system according to claim 1, further comprising a means for receiving the results after the contents of the request form are sent and checked by the typographical error detection means and the amount extraction means.

[1744] (Claim 3)

[1745] A means including a natural language processing model for searching past approval request data;

[1746] A means of extracting similar approval documents from the search results,

[1747] A means for presenting the decision result of the extracted request form;

[1748] 10. The system of claim 1, comprising:

[1749] "Application Example 1"

[1750] (Claim 1)

[1751] means including a natural language processing model for detecting typos; and

[1752] a means for extracting the amount stated in the request form f...

Claims

1. means including a natural language processing model for detecting typos; and A means for extracting the amount stated in the request form from the estimate, A means for comparing the amount stated in the request form with the amount extracted from the estimate; means for generating an error message based on the comparison result; means for presenting said error message to a user; A system including:

2. The system according to claim 1, further comprising means for transmitting the contents of the request form and receiving the results after the contents have been checked by the typographical error detection means and the amount extraction means.

3. A means including a natural language processing model for searching past approval request data; A means of extracting similar approval documents from the search results, A means for presenting the decision result of the extracted request form; The system of claim 1 , comprising:

4. 2. The system of claim 1, further comprising an automatic correction means for performing said correction function.

5. 10. The system of claim 1, further comprising a terminal including an interface for displaying said error message to a user.

Images