System

Abstract

A system is provided.SOLUTION: The system includes a means for transmitting application contents from terminals to a server, a means for allowing a generation AI to learn past information and examine the application contents, a means for visualizing error points on the basis of the examination result of the generation AI, a means for notifying a user of the error points and correction contents, and a means for collecting the feedback of the user and allowing the generation AI to relearn.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] When approvers and decision makers for application projects review and make decisions on application content, they often spend a lot of time and effort pointing out typos and incomplete descriptions. Furthermore, when a resubmission is made, they have to go through the trouble of checking it again, which reduces work efficiency. This causes problems, such as the approvers and decision makers being unable to focus on the important tasks they should be focusing on. [Means for solving the problem]

[0005] The present invention provides a system that includes a means for transmitting application content from a terminal to a server, a means for a generation AI to learn from past data and scrutinize the application content, a means for visualizing error points based on the generation AI's scrutiny results, a means for notifying the user of the error points and correction details, and a means for collecting user feedback and having the generation AI re-learn. This system quickly detects errors or missing information in the application content and notifies approvers and decision makers, thereby reducing their workload and providing an environment where they can efficiently focus on their core tasks.

[0006] "Application content" refers to the information and data that the user inputs via the terminal and sends to the server.

[0007] "Terminal" refers to a device used by a user to enter application details, such as a computer, smartphone, or tablet.

[0008] The "server" is a central management system that receives application details and performs AI generation and other processing.

[0009] "Generative AI" refers to artificial intelligence that learns from past approval and denial histories and uses them to scrutinize new applications.

[0010] "Error points" refer to errors or missing information found in the application content by the generation AI after careful examination.

[0011] "Visualization means" refers to methods and tools that display and notify users of error points in a way that is easy for them to understand.

[0012] "User" refers to all system users, including applicants who input and submit application details, and approvers and decision makers who check and approve or reject application details.

[0013] "Feedback" refers to the results of corrections, approvals, or rejections made by the user regarding the application, as well as any comments.

[0014] "Relearning" refers to the learning process that generative AI goes through to improve its accuracy in future generations based on new data and feedback. [Brief explanation of the drawings]

[0015] [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

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

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

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

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

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

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

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

[0023] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0036] This invention is a system that utilizes generation AI to approve or reject application content, reducing the burden on approvers and decision makers. The main components of this system are a terminal, a server, and generation AI.

[0037] Program processing

[0038] Data collection and learning

[0039] The server collects data such as past application details, approval / rejection history, and comments, and provides it to the generation AI.

[0040] Based on this data, the generative AI learns patterns such as typos and incomplete descriptions.

[0041] Acceptance and review of application details

[0042] The user (applicant) enters a new application into the form from the terminal and submits it.

[0043] The terminal transmits the input application details to the server.

[0044] The server receives the application data and passes it to the generation AI.

[0045] The generation AI scrutinizes the application content and detects errors such as typos and missing information.

[0046] Alerts and Notifications

[0047] The server identifies the areas to be corrected based on the error report from the generation AI and visualizes the error points.

[0048] The server notifies the users (applicant and approver) of any corrections or points to note.

[0049] Correct and resubmit

[0050] The user (applicant) corrects the application details on the terminal and resubmits it.

[0051] The terminal sends the corrected application details to the server again.

[0052] Re-examination and final confirmation

[0053] The server passes the resubmitted application data to the generation AI and conducts a re-examination.

[0054] The generating AI will re-examine it to make sure there are no problems.

[0055] Approval or rejection decision

[0056] The user (approver / decisor) checks the final error report to confirm that the corrections have been completed and approves or rejects the application.

[0057] Feedback and Retraining

[0058] The server collects feedback data and retrains the generating AI to improve accuracy in future generations.

[0059] Specific examples

[0060] For example, consider the process of applying for a business trip. An example will be explained in which a user inputs details such as the purpose of the business trip, schedule, and expenses from a terminal and submits the information.

[0061] The user (applicant) fills in the business trip application form and submits it.

[0062] The terminal sends the application details to the server.

[0063] The server passes the application data to the generation AI, which then examines the contents.

[0064] The generation AI detects errors such as "a typo in an expense item or an incomplete accommodation address."

[0065] The server sorts out the error points and notifies the users (applicant and approver).

[0066] The user (applicant) resubmits the corrected content.

[0067] The generating AI will re-examine the data to ensure that the problem has been resolved.

[0068] The user (approver / decisor) performs the final check and approves or rejects the application.

[0069] The server collects feedback and retrains the generative AI.

[0070] In this way, we aim to streamline the approval process for business trip applications and significantly reduce the burden on approvers and decision makers.

[0071] The processing flow will be explained below.

[0072] Step 1:

[0073] The user (applicant) enters a new application into the form from a terminal. The application contents include necessary information (e.g., name, purpose, schedule, expenses, etc.).

[0074] Step 2:

[0075] The terminal sends the entered application details to the server, which then receives the application data.

[0076] Step 3:

[0077] The server passes the received application data to the generation AI, which then begins the process of examining the application content.

[0078] Step 4:

[0079] The generation AI then scrutinizes the application, detecting errors such as typos, missing required fields, and inconsistent information.

[0080] Step 5:

[0081] The server receives the error report from the generation AI, identifies which part of the application content is problematic, and visualizes the error point.

[0082] Step 6:

[0083] The server notifies the user (applicant and approver) of the error and the corrections required. This notification is often done via email or dashboard.

[0084] Step 7:

[0085] The user (applicant) checks the error report and corrects the application content. The corrections include the errors identified by the generation AI.

[0086] Step 8:

[0087] The user (applicant) resends the revised application details from the terminal to the server.

[0088] Step 9:

[0089] The server passes the corrected application data to the generation AI again for re-examination. The generation AI then checks whether the previous error has been resolved.

[0090] Step 10:

[0091] The generation AI returns the results after re-examination to the server, and if the problem has been resolved, a report with no errors is provided.

[0092] Step 11:

[0093] The server notifies the user (approver / decisor) of the final error report, indicating whether the error has been resolved or whether a new error has occurred.

[0094] Step 12:

[0095] The user (approver / decisor) checks the application content based on the final error report and decides whether to approve or reject it.

[0096] Step 13:

[0097] Users (approvers and decision makers) enter their approval or rejection feedback into the system, which is important for future learning.

[0098] Step 14:

[0099] The server collects feedback and provides it to the generative AI as data for retraining, which improves accuracy in future iterations.

[0100] The above are the specific processing steps in the system of the present invention.

[0101] Example 1

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

[0103] In today's business environment, the time and effort required for the approval and rejection process for application content is a major challenge. In particular, frequent typos and incomplete descriptions require repeated corrections and resubmissions, placing a heavy burden on approvers and decision makers. Furthermore, technology that learns from past application data to improve the accuracy of review has not yet been fully established, preventing an efficient process. To address these challenges, a system is needed that efficiently reviews application content, notifies users, and provides guidance on how to make corrections.

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

[0105] In this invention, the server includes means for transmitting application content from a terminal to the server, means for the generation AI to learn from past data and scrutinize the application content, means for visualizing error points based on the generation AI's scrutiny results, means for notifying the user of the error points and correction details, means for collecting user feedback and having the generation AI re-learn, means for sending the application content to the server again and having the generation AI re-scrutinize it if the application content is corrected, and means for notifying the user (approver / decisor) of the re-scrutiny results and prompting them to make a final decision. This makes it possible to streamline the application content scrutiny and correction process and significantly reduce the burden on approvers and decision makers.

[0106] "Application content" refers to the data that a user inputs and submits via a terminal to request approval or authorization.

[0107] The "server" is a computer system that sends and receives application details, provides data to the generation AI, and visualizes and notifies error points.

[0108] "Generative AI" is an algorithm or model that learns patterns such as typos and incomplete descriptions based on past application data and then scrutinizes the application content.

[0109] "Error point" is a term that refers to the points where the generation AI detects problems such as typos or insufficient information after carefully examining the application content.

[0110] "User" refers to the applicant who inputs and submits the application details, and the approver / decisor who ultimately approves or rejects the application.

[0111] "Feedback" refers to the evaluations and comments regarding the application collected from users, as well as the results of approval or rejection.

[0112] "Relearning" is the process by which generative AI updates its model based on newly collected feedback data to improve its accuracy.

[0113] "Scrutiny" is a process in which the generation AI analyzes the application content in detail and detects errors such as typos and missing information.

[0114] "Notification" is a means of information transmission by the server to inform the user of the error point and the correction content.

[0115] "Re-examination" is a process in which the generation AI re-analyzes in detail the application content corrected by the user to confirm whether any errors detected previously have been resolved.

[0116] This invention is a system that aims to improve the efficiency of approving or rejecting application content, and mainly utilizes a server, terminals, and a generative AI model. This system uses past application data for the generative AI to learn and examine, reducing the burden on users.

[0117] Hardware and software used

[0118] This system uses the following hardware and software:

[0119] Server: A server machine for high-performance data processing. For example, we will use an AWS EC2 instance.

[0120] Device: A PC or mobile device used by applicants and approvers, using a web browser (such as Google Chrome or Mozilla Firefox).

[0121] Generative AI model: An AI model that learns from past data and scrutinizes application content. It uses TensorFlow and PyTorch.

[0122] Data processing and calculation

[0123] The operation of this system is as follows.

[0124] First, the server collects data such as past application details, approval / denial history, and comments, and provides it to the generation AI. The generation AI then learns from this collected data and creates a model that can identify patterns such as typos and incomplete descriptions.

[0125] Next, the user (applicant) enters the necessary information into the application form on their device and submits it. The device then sends this application data to the server, which then passes it on to the generation AI. The generation AI then carefully examines the application content and detects errors such as typos and missing information.

[0126] Based on the results of the generative AI's inspection, the server visualizes the error points and notifies the user of corrections and points to note. By receiving this notification, users (applicants and approvers) can be sure to understand which parts need to be corrected.

[0127] The user (applicant) then corrects any corrections and submits the data again. The server passes the corrected application data back to the generation AI, which then re-examines it. Once the server confirms that there are no problems, it sends a notification to the user (approver / decisor) for final confirmation.

[0128] Finally, the server collects feedback data and retrains the generative AI to improve accuracy in future iterations. By continuing this feedback process, the system is always adapting to the latest evaluation criteria, enabling more accurate scrutiny.

[0129] Specific examples

[0130] For example, to explain the process of applying for a business trip as a specific example, the user (applicant) enters details such as the purpose of the business trip, schedule, and expenses on a terminal and submits them. The application data is sent to the server, and the generation AI detects errors such as "a typographical error in the expense item or an incomplete accommodation address." The server sorts out the error points and notifies the users (applicant and approver). The user resubmits the corrected content, and the generation AI re-examines it. After confirming that the problem has been resolved, the user (approver / decisor) makes a final check and approves or rejects the application. The server collects feedback and allows the generation AI to re-learn.

[0131] Prompt Sentence Examples

[0132] "What should I pay attention to when filling out a business trip application?"

[0133] "I want to learn about common mistakes made in past applications."

[0134] Please provide a detailed explanation as to why your application was rejected.

[0135] In this way, we aim to streamline the approval process for business trip applications and significantly reduce the burden on approvers and decision makers.

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

[0137] Step 1:

[0138] The server collects data such as past application details, approval / rejection history, and comments.

[0139] Specific operation: The server connects to the business management system database and extracts travel request data from the past year using an SQL query.

[0140] Input: Historical data from business management systems

[0141] Output: Past application data extracted from the database

[0142] Step 2:

[0143] The server provides the collected data to the generation AI.

[0144] Specific operation: The server converts the extracted data into JSON format and sends it to the generative AI's learning module using an HTTP request.

[0145] Input: Extracted past application data

[0146] Output: Training data sent to the generation AI

[0147] Step 3:

[0148] The generative AI learns patterns such as typos and incomplete descriptions based on the data provided.

[0149] What it does: Generative AI uses the data you send it to identify patterns of typos, omissions, and imperfections and trains a neural network model.

[0150] Input: Past application data including typos and incomplete descriptions

[0151] Output: A trained generative AI model

[0152] Step 4:

[0153] The user (applicant) enters a new application into the form from the terminal and submits it.

[0154] Specific operation: The user fills in the necessary information in the travel request form on the browser and clicks the submit button.

[0155] Input: Application information entered by the user into the form

[0156] Output: Application data sent from the terminal

[0157] Step 5:

[0158] The terminal transmits the input application details to the server.

[0159] Specific operation: The terminal converts the input content into XML format and sends it to the server using SSL.

[0160] Input: Application data from the form

[0161] Output: Request data sent to the server

[0162] Step 6:

[0163] The server receives the application data and passes it to the generation AI.

[0164] Specific operation: The server sends the received application data to the generation AI's inspection module.

[0165] Input: Application data sent from the terminal

[0166] Output: Application data sent to the generation AI

[0167] Step 7:

[0168] The generation AI scrutinizes the application content and detects errors such as typos and missing information.

[0169] Specific operation: The generation AI analyzes the application data and detects errors such as "a typo in the expense item" or "an incomplete address for the accommodation."

[0170] Input: Application data

[0171] Output: Error report

[0172] Step 8:

[0173] The server identifies the areas to be corrected based on the error report from the generated AI and visualizes the error points.

[0174] Specific operation: The server analyzes the error report from the generated AI and highlights the error point in red on the web interface.

[0175] Input: Error report from the generation AI

[0176] Output: Visualized error points

[0177] Step 9:

[0178] The server notifies the users (applicant and approver) of any corrections or points to note.

[0179] Specific operation: The server uses the email notification system to send detailed emails including the error point to the applicant and approver.

[0180] Input: Visualized error points

[0181] Output: Notification email showing corrections and points to note

[0182] Step 10:

[0183] The user (applicant) corrects the application details on the terminal and resubmits it.

[0184] Specific actions: The user checks the error email, corrects the indicated items on the form, and clicks the resubmit button.

[0185] Input: Corrected application data

[0186] Output: Resubmitted application data

[0187] Step 11:

[0188] The terminal sends the corrected application details to the server again.

[0189] Specific operation: The terminal re-enters the data and sends it to the server.

[0190] Input: Corrected application data

[0191] Output: Request data resubmitted to the server

[0192] Step 12:

[0193] The server passes the resubmitted application data to the generation AI and conducts a re-examination.

[0194] Specific operation: The server updates the corrected application data and transfers it again to the generation AI's inspection module.

[0195] Input: Resubmitted application data

[0196] Output: Data resubmitted to the generating AI

[0197] Step 13:

[0198] The generating AI will re-examine it to make sure there are no problems.

[0199] Specific behavior: The generation AI analyzes the data again and generates a final error report.

[0200] Input: Resubmitted application data

[0201] Output: Error report of re-examination results

[0202] Step 14:

[0203] The user (approver / decisor) checks the final error report to confirm that the corrections have been completed and approves or rejects the application.

[0204] Specific operation: The approver checks the error report and clicks the approve or reject button on the system.

[0205] Input: Error report of re-examination results

[0206] Output: Approval or rejection decision

[0207] Step 15:

[0208] The server collects feedback data and retrains the generating AI to improve accuracy in future generations.

[0209] Specific operation: The server records the approval / denial results in a database and periodically reflects them in the learning module of the generation AI.

[0210] Input: Approval / Rejection result feedback

[0211] Output: Retrained generative AI model

[0212] (Application example 1)

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

[0214] At logistics centers, when workers replenish inventory or submit various applications, typographical errors or insufficient information in the application content can delay the approval process and reduce work efficiency. Another problem is the burden placed on approvers and decision makers when processing a huge number of applications. To solve these issues, a system is needed that streamlines the review and revision of application content and speeds up the approval process.

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

[0216] In this invention, the server includes means for transmitting application content from an information processing device to a database server, means for a generation AI to learn past data and analyze the application content, means for visualizing error points based on the analysis results of the generation AI, means for notifying an operator of the error points and correction details, means for collecting operator feedback and having the generation AI re-learn, means for an operator to input and correct the application content by voice input or gesture using smart glasses, and means for approving or rejecting the application content via the smart glasses. This makes it possible to quickly detect and correct errors in the application content and streamline the approval process.

[0217] An "information processing device" is a device for data entry, calculation, and information processing.

[0218] A "database server" is a server that centrally stores data and allows multiple users to access it via a network.

[0219] "Generative AI" is a type of artificial intelligence model that can learn from large amounts of data and apply it to new data.

[0220] "Visualization" is the process of making data and information easier to understand by displaying them in a visual format such as a graph or chart.

[0221] "Operator" means a person or device whose role is to operate and manage a machine or system.

[0222] "Smart glasses" are glasses-type devices equipped with displays and sensors that provide functions such as augmented reality and voice input.

[0223] "Voice input" is a technology or method for recognizing a person's voice and converting that speech into text or commands.

[0224] "Gestures" refer to giving instructions or performing operations using hand or body movements.

[0225] "Application" means the details of a formal request or proposal submitted for a specific purpose.

[0226] "Analysis" is the process of breaking down data or information to understand its structure and meaning.

[0227] An "approval process" is a series of procedures that review submitted applications and requests and determine whether to approve them.

[0228] "Feedback" is information about evaluations and reactions to a system or process, which can lead to improvements or adjustments.

[0229] "Retraining" means that generative AI uses new data and feedback to train the model again in order to improve its accuracy and performance.

[0230] This invention is a system for streamlining application processes at logistics centers, and in particular supports the review and approval of application contents for inventory replenishment, etc. The system's main components are an information processing device, a database server, a generation AI, and smart glasses.

[0231] System configuration and operation

[0232] 1. Hardware and Software Used

[0233] Information processing devices: smart glasses (e.g., Google Glass Enterprise Edition 2)

[0234] Database server: High-performance computing server, AWS (Amazon Web Services) infrastructure

[0235] Generated AI: OpenAI GPT-4 API

[0236] Text analysis library: SpaCy

[0237] 2. Data collection and learning

[0238] The server stores data such as past inventory requests, approval / denial history, and comments in an AWS RDS database. This data is provided to OpenAI GPT-4, which learns patterns of typos and incomplete descriptions. This improves the generative AI's ability to efficiently review requests.

[0239] 3. Acceptance and review of application details

[0240] Using smart glasses, workers input new requests (e.g., "I would like to request a replenishment of stock for Type III materials on the next shelf X. The current stock quantity is 10.") into a form using voice input or gestures, and then send the request to the server via the smart glasses. The server then passes the request details to the generation AI via AWS's closed API, and the AI ​​detects errors such as typos and missing information.

[0241] 4. Warnings and Notifications

[0242] The server receives the error report from the AI ​​generator and visualizes the error points based on the report. The visualized error points and points of caution are then notified to the worker via the smart glasses display.

[0243] 5. Corrections and resubmissions

[0244] Workers can use voice input or gestures through the smart glasses to amend the application details, which are then sent back to the server and passed to the AI ​​for further review.

[0245] 6. Re-examination and final confirmation

[0246] The server then uses the AI ​​to analyze the resubmitted application data and check whether the problems have been resolved. If all errors have been corrected, the server notifies the worker via the smart glasses.

[0247] 7. Decision on Approval or Rejection

[0248] The logistics center manager uses the smart glasses to approve or reject the application based on the final error report, thereby completing the application process.

[0249] 8. Feedback and Retraining

[0250] The server collects feedback data on approvals and denials and retrains the generating AI, improving accuracy from the next time onwards.

[0251] Specific examples

[0252] For example, consider a worker speaking the following prompt into smart glasses:

[0253] "I would like to request a replenishment of the next shelf, X, of Type III materials. The current stock quantity is 10."

[0254] The generative AI converts speech to text and analyzes the application to detect error points such as:

[0255] "There is a typo in your inventory replenishment request. Please check again."

[0256] Workers can make corrections and resubmit through the smart glasses, streamlining the application process.

[0257] Example prompt sentence:

[0258] Stock replenishment request:

[0259] Shelf: X

[0260] Product name: III type material

[0261] Currently in stock: 10

[0262] Is there a typo or incompleteness in the above content? Please provide detailed feedback.

[0263] As described above, the present invention is a practical system that significantly improves work efficiency by combining generative AI and smart glasses.

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

[0265] Step 1:

[0266] The server collects and stores data such as past inventory requests, approval / denial history, and comments in an AWS RDS database. This prepares a dataset for the generative AI to learn from. The input is past inventory request data, and the output is the prepared dataset.

[0267] Step 2:

[0268] The server provides the collected dataset to the generative AI (OpenAI GPT-4 API). The generative AI uses this to learn patterns of typos and incomplete descriptions. The input is past inventory request data, and the output is the trained generative AI model. Specifically, the dataset is sent in JSON format to the generative AI API, and the model is trained.

[0269] Step 3:

[0270] The user (worker) uses the smart glasses to input new application details using voice input or gestures. The input is the application details as voice, and the output is the application details converted to text. The smart glasses' microphone and voice recognition software are used to convert the voice to text.

[0271] Step 4:

[0272] The terminal (smart glasses) sends the textual application details to a database server. The input is the textual application details, and the output is the application data stored on the server.

[0273] Step 5:

[0274] The server passes the received application data to the generation AI for scrutiny. The generation AI analyzes the application content and detects errors such as typos and insufficient information. The input is the text version of the application content, and the output is an error report. Specifically, the application data is sent to the generation AI API and the analysis results are obtained.

[0275] Step 6:

[0276] The server visualizes the error points based on the error report from the generation AI. The input is the error report, and the output is the visualized error points. Specifically, it generates text highlighting the error points and sends it to the smart glasses.

[0277] Step 7:

[0278] The user (worker) checks the error points through the smart glasses and corrects the application details using voice input or gestures. The input is the visualized error points and voice input, and the output is the corrected application details.

[0279] Step 8:

[0280] The terminal (smart glasses) sends the corrected application details back to the database server. The input is the corrected application details, and the output is the corrected application data stored on the server.

[0281] Step 9:

[0282] The server passes the resubmitted application data to the generation AI for re-examination. The generation AI analyzes the application again and checks whether the problem has been resolved. The input is the corrected application content, and the output is the final error report.

[0283] Step 10:

[0284] The server confirms that the correction is complete based on the final error report and notifies the worker of this via the smart glasses. The input is the final error report, and the output is the approval notification.

[0285] Step 11:

[0286] The user (logistics center manager) uses the smart glasses to perform the final approval or rejection of the application. The input is the approval notification, and the output is the approval or rejection decision.

[0287] Step 12:

[0288] The server collects feedback data on approvals and denials and retrains the generative AI. The input is the feedback data, and the output is an even more accurate generative AI model.

[0289] This processing flow makes it possible to quickly detect and correct errors in application content and streamline the approval process.

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

[0291] This invention is a system that utilizes generative AI to approve or reject application content, and also combines it with an emotion engine that recognizes user emotions, with the aim of reducing the burden on approvers and decision makers. This section explains the specific components and processing flow of this system.

[0292] Program processing

[0293] Data collection and learning

[0294] The server collects data such as past application details, approval / rejection history, and comments, and provides it to the generation AI.

[0295] Based on this data, the generative AI learns patterns such as typos and incomplete descriptions.

[0296] Acceptance and review of application details

[0297] The user (applicant) enters a new application into the form from the terminal and submits it.

[0298] The terminal transmits the input application details to the server.

[0299] The server receives the application data and passes it to the generation AI.

[0300] The generation AI scrutinizes the application content and detects errors such as typos and missing information.

[0301] Alerts and Notifications

[0302] The server identifies the areas to be corrected based on the error report from the generation AI and visualizes the error points.

[0303] The server notifies the users (applicant and approver) of any corrections or points to note.

[0304] Emotion data collection and analysis

[0305] The emotion engine collects emotional data (e.g., facial expressions, tone of voice, input speed, etc.) when users (applicants and approvers) operate the system.

[0306] The server provides the emotion data collected from the emotion engine to the generation AI for analysis.

[0307] Correct and resubmit

[0308] The user (applicant) checks the error report and corrects the application content. The corrections include the errors identified by the generation AI.

[0309] The terminal sends the corrected application details to the server again.

[0310] Re-examination and final confirmation

[0311] The server passes the corrected application data to the generation AI again for re-examination. The generation AI then checks whether the previous error has been resolved.

[0312] The generation AI returns the results after re-examination to the server, and if the problem has been resolved, a report with no errors is provided.

[0313] Approval or rejection decision

[0314] The user (approver / decisor) checks the application contents based on the final error report and decides whether to approve or reject it.

[0315] The emotion engine recognizes the emotions that approvers and decision makers feel when making decisions and adjusts the form of feedback as needed.

[0316] Feedback and Retraining

[0317] The server collects feedback data and provides it to the generation AI as data for re-learning, which improves accuracy in future iterations.

[0318] The generative AI also learns from emotional data to optimize future notification processes and feedback methods.

[0319] Specific examples

[0320] For example, the approval process for a new project proposal may involve the following steps: Let us consider an example in which a user inputs and submits a project proposal from a terminal.

[0321] The user (applicant) fills out the project proposal form and submits it.

[0322] The terminal transmits the input proposal to the server.

[0323] The server passes the proposal data to the generation AI, which then scrutinizes the content, detecting typos and missing data.

[0324] The emotion engine recognizes the user's emotions and detects, for example, if the user is in a hurry or stressed.

[0325] The server visualizes the error point and notifies the user (applicant and approver).

[0326] The user (submitter) makes corrections and resubmits. The emotion engine also evaluates the user's state at the time of resubmission.

[0327] The generating AI will re-examine the data to ensure that the problem has been resolved.

[0328] The user (approver / decisor) makes a final check and approves or rejects the proposal. The emotion engine recognizes the emotion at the time of decision and adjusts the feedback format accordingly.

[0329] The server collects feedback and retrains the generative AI, optimizing the process for future iterations.

[0330] In this way, the present invention not only improves the efficiency of the application process, but also enables flexible responses according to the emotional state of the user, thereby significantly reducing the burden on approvers and decision makers.

[0331] The processing flow will be explained below.

[0332] Step 1:

[0333] The user (applicant) enters a new application into the form from a terminal. The application contents include necessary information (e.g., name, purpose, schedule, expenses, etc.).

[0334] Step 2:

[0335] The terminal sends the input application content and emotional data (e.g., facial expressions, tone of voice, input speed, etc.) during the user's operation to the server. The emotional data is collected by the emotion engine.

[0336] Step 3:

[0337] The server passes the received application data and emotion data to the generation AI, which then begins the process of examining the application content and analyzing the emotion data simultaneously.

[0338] Step 4:

[0339] The generative AI then scrutinizes the application, detecting errors such as typos, missing required fields, and inconsistent information, and also analyzes emotional data to assess the user's state.

[0340] Step 5:

[0341] The server receives the error report and sentiment analysis results from the AI ​​generation, identifies which part of the application content has a problem, and visualizes the error point. The sentiment analysis results are also included in the report.

[0342] Step 6:

[0343] The server notifies users (applicants and approvers) of the error points and corrections. The notification method is adjusted according to the user's emotional state (e.g., if the user is feeling stressed, the notification will be in gentle language).

[0344] Step 7:

[0345] The user (applicant) checks the error report and emotional advice and corrects the application. The corrections include the errors identified by the generation AI.

[0346] Step 8:

[0347] The user (applicant) resends the revised application details from the terminal to the server. At the same time, the emotion engine collects the user's emotion data again at the time of resending.

[0348] Step 9:

[0349] The server passes the corrected application data and emotion data to the generation AI again for re-examination. The generation AI then checks whether the previous error has been resolved.

[0350] Step 10:

[0351] The generative AI then returns the results to the server after further review. If the problem has been resolved, it will provide an error-free report. At the same time, it also analyzes emotional data to evaluate the user's state.

[0352] Step 11:

[0353] The server notifies the user (approver / decisor) of the final error report and the result of the sentiment analysis. The content of the notification is adjusted based on the user's emotional state.

[0354] Step 12:

[0355] The user (approver / decisor) checks the application content based on the final error report and decides whether to approve or reject it. The emotion engine recognizes the emotions of the approver / decisor when making the decision and adjusts the feedback format as necessary.

[0356] Step 13:

[0357] Users (approvers and decision makers) enter their approval or rejection feedback into the system, which is important for future learning.

[0358] Step 14:

[0359] The server collects feedback and provides it to the generative AI as retraining data, which includes emotional data to optimize future processing.

[0360] The above are the specific processing steps in the system of the present invention. Through this flow, it is possible to streamline the application process while taking into account the emotional state of the user, and significantly reduce the burden on approvers and decision makers.

[0361] Example 2

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

[0363] In the conventional application process, detecting and correcting typos and missing information requires a great deal of time and effort. It also places a heavy psychological burden on approvers and decision makers when they review application documents. Furthermore, while flexible responses based on user emotions are required, this is not being fully implemented. As a result, the entire application process is inefficient, resulting in a poor user experience.

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

[0365] In this invention, the server includes means for transmitting application content from the terminal to the server, means for the server to collect past application data and provide it to the generation AI, means for the generation AI to learn about typos and incomplete descriptions based on the past data and scrutinize the application content, means for visualizing error points based on the generation AI's scrutiny results, means for notifying the user of the error points and corrections, means for the emotion engine to collect user emotion data and provide it to the generation AI, means for re-sending application content corrected by the user to the server and re-scrutinizing it, and means for collecting user feedback and having the generation AI re-learn. This makes it possible to quickly and accurately detect typos and insufficient information and provide flexible feedback according to the user's psychological state.

[0366] 1. "Submission" means any document or information submitted by a User and sent to the Server for a specific purpose, such as proposing a new project or applying for rights.

[0367] 2. "Device" refers to the electronic device used by the user to input and submit application details, including personal computers, smartphones, tablets, etc.

[0368] 3. "Server" refers to the central processing unit that receives the application details sent from the terminal and processes and analyzes the data in cooperation with the generation AI and emotion engine.

[0369] 4. "Generative AI" refers to automated artificial intelligence models that learn from past data and scrutinize applications for typos and incomplete descriptions. For example, they use natural language processing technology to analyze documents.

[0370] 5. "Error points" are typos or missing information detected by the generation AI when examining the application content, and are visualized to prompt the user to make corrections.

[0371] 6. "Emotion engine" refers to technology that collects emotional data from a user's facial expressions, tone of voice, input speed, etc., and recognizes the user's psychological state.

[0372] 7. "Feedback" refers to response information that notifies the user of the results of the generative AI's inspection and information on error points, allowing the user to make corrections based on that information.

[0373] 8. "Retraining" is the process by which the system retrains the generative AI based on newly collected data and user feedback to improve accuracy and efficiency in future generations.

[0374] MODE FOR CARRYING OUT THE INVENTION

[0375] This invention is a system that realizes efficient application processes and flexible responses according to the user's emotional state. This system consists of a terminal, a server, a generation AI, and an emotion engine. The specific functions of each component and their execution procedures are explained below.

[0376] Hardware and software used

[0377] Terminal: Electronic device used by the user to input and submit application details. Examples include personal computers, smartphones, and tablets.

[0378] Server: A central processing unit that receives the application details and processes and analyzes the data in cooperation with the generative AI and emotion engine.

[0379] Generative AI: An automated artificial intelligence model that learns from historical data to refine applications, using natural language processing techniques such as GPT-4.

[0380] Emotion engine: Dedicated software and hardware for analyzing a user's facial expressions, tone of voice, and typing speed to collect emotional data.

[0381] Specific operation explanation

[0382] 1. Acceptance of application details

[0383] The user opens an application form on their device and enters the details of the application, such as a new project proposal or rights application. Once the input is complete, they press the send button to send the data to the server. At this time, the device sends the data securely using the HTTPS protocol.

[0384] 2. Receipt and provision of data

[0385] The server receives the application details sent from the device. At the same time, the server accesses the company's database to collect past application details and approval / denial history, and provides this information to the generation AI. This allows the generation AI to learn from past patterns and improve the accuracy of detecting typos and missing information.

[0386] 3. Review of application details

[0387] The generation AI analyzes the received application content and detects typos and missing information. For example, if there are any typos, it will identify them and also present any required information that is missing from the application content.

[0388] 4. Visualization and notification of error points

[0389] The server visualizes the error points in the application based on the error report returned by the generation AI. Specifically, it highlights the error points in red and notifies the user with instructions to correct them. This notification is sent via email or within the system.

[0390] 5. Emotional Data Collection and Analysis

[0391] The emotion engine collects facial expressions, tone of voice, and input speed in real time when the user edits the application. This emotional data is sent to the server and provided to the generation AI. Based on this data, the generation AI analyzes the user's psychological state, such as whether they are feeling stressed.

[0392] 6. Re-examination and final confirmation

[0393] After the user has completed the corrections, they send the application details back to the server. The server then provides the data to the generation AI again and re-examines it. If the errors have been resolved, a report of the correct status is returned, and the approver makes a final confirmation.

[0394] 7. Feedback and Retraining

[0395] The approver reviews the final error report and makes a decision to approve or reject it. At the same time, the emotion engine analyzes the approver's emotions and adjusts the feedback format as necessary. The server collects the feedback data and retrains the generation AI to further improve accuracy in future iterations.

[0396] Examples of specific examples and prompts

[0397] For example, the approval process for a new project proposal may involve the following steps: Let us consider an example in which a user inputs and submits a project proposal from a terminal.

[0398] 1. Review the project proposal

[0399] "You have entered a new project proposal. Please check for typos and missing information."

[0400] 2. Generate an error report

[0401] "Please create an error report for this project proposal and point out any corrections that need to be made."

[0402] 3. Emotion Data Analysis

[0403] "Analyze whether the user is feeling stressed or not from facial expression data."

[0404] This allows the system to streamline the application process and respond flexibly to the user's emotional state.

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

[0406] Program processing flow

[0407] Step 1:

[0408] Input: A user opens an application form on their device and enters details of an application, such as a new project proposal or rights application.

[0409] Specific operation: The user enters the required information into the form on the terminal and presses the submit button.

[0410] Output: Input data is sent from the device to the server.

[0411] Step 2:

[0412] Input: Application details sent from the terminal

[0413] Specific operation: The server receives data from the device and saves the application details. At the same time, it accesses the company's database to collect past application data and approval / denial history, and provides this information to the generation AI.

[0414] Output: Saved application data and learning data used by the generation AI

[0415] Step 3:

[0416] Input: Past data and new application details provided by the server

[0417] How it works: The generation AI uses natural language processing technology to learn patterns of typos and incomplete descriptions based on past data and then scrutinize the content of new applications.

[0418] Output: Results of review of new application (error report)

[0419] Step 4:

[0420] Input: The inspection result (error report) returned by the generation AI

[0421] Specific operation: The server receives the error report from the generation AI and visualizes the error points. Specifically, it highlights typos and missing information in red and generates correction instructions.

[0422] Output: A visualized error report

[0423] Step 5:

[0424] Input: A visualized error report

[0425] What happens: The server will send a notification to the user containing the error and instructions on how to fix it. This notification can be done via email or an in-system notification.

[0426] Output: Notification of fix to user

[0427] Step 6:

[0428] Input: Facial expressions, tone of voice, typing speed, etc. when users operate the system

[0429] Specific operation: The emotion engine collects the user's emotion data and sends it to the server. The emotion engine collects data using the camera and microphone.

[0430] Output: Emotion data

[0431] Step 7:

[0432] Input: Emotion data sent from the emotion engine

[0433] Specific operation: The server provides emotional data to the generation AI via an analysis API. The generation AI analyzes this emotional data and determines the user's psychological state.

[0434] Output: Psychological state as a result of analysis

[0435] Step 8:

[0436] Input: Application details for which corrections have been notified

[0437] Specific operation: The user corrects the application details based on the error report and presses the submit button again, which causes the corrected data to be resent to the server.

[0438] Output: Corrected application data

[0439] Step 9:

[0440] Input: Corrected application data

[0441] Specific operation: The server provides the correction data to the generation AI again and performs a re-examination. The generation AI checks whether the previous error has been resolved.

[0442] Output: Re-examination result (determining whether the issue has been resolved)

[0443] Step 10:

[0444] Input: Re-examination results

[0445] Specific operation: The server provides the re-examination results to the approver, who makes a final decision based on the error report and the re-examination results.

[0446] Output: Approval or rejection decision

[0447] Step 11:

[0448] Input: Approver's final decision and feedback

[0449] How it works: The server collects feedback and provides it to the generation AI as retraining data, which allows the generation AI to improve its accuracy in future generations.

[0450] Output: Data for retraining

[0451] (Application example 2)

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

[0453] Conventional application review systems using generative AI provide uniform feedback without considering the user's emotional state, which can lead to increased stress and dissatisfaction. Furthermore, the application of review results is not flexible and does not take into account the user's emotions, which increases the burden on approvers and decision makers. The present invention aims to solve these problems.

[0454] 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 for transmitting application content from a terminal to the server, means for the generation AI to learn past data and scrutinize the application content, means for visualizing error points based on the generation AI's scrutiny results, means for notifying the user of the error points and correction details, means for collecting user emotion data and providing it to the emotion engine, means for the emotion engine to analyze the user emotion data and provide the analysis results to the generation AI, and means for collecting user feedback and having the generation AI re-learn. This enables the generation AI to take the user's emotional state into consideration and provide optimal feedback, while also reducing the burden on approvers and decision makers.

[0455] "Application content" refers to the data and information that the user sends to the server.

[0456] "Terminal" refers to an input device used by a user, and includes PCs, tablets, smartphones, etc.

[0457] A "server" is a central computer system that collects, processes, and stores data.

[0458] "Generative AI" is an artificial intelligence system that learns from past data and scrutinizes application content and detects errors.

[0459] "Error points" refer to problematic areas such as typos, omissions, and deficiencies that the generation AI detects in the application content.

[0460] "Visualization" refers to displaying data or information visually to make it easier for users to understand.

[0461] "Emotion data" refers to information such as the user's facial expression, tone of voice, and input speed, and is data used by the emotion engine for analysis.

[0462] The "emotion engine" is a system that analyzes the user's emotional data and recognizes and evaluates their emotional state.

[0463] "Feedback" refers to information that provides a user with notice or instructions regarding error points and corrections.

[0464] "Retraining" refers to the process by which generative AI retrains itself based on new data and feedback to improve its accuracy.

[0465] The present invention is a system that combines generative AI and an emotion engine to approve or reject application content. The specific components and operating procedures for realizing this system are described below.

[0466] The system configuration consists of a terminal, a server, a generative AI, an emotion engine, and a means of communication to link them together.

[0467] 1. Enter and submit your application details

[0468] The user enters the application details from a device (PC, tablet, smartphone, etc.). After input, the application details are sent from the device to the server. At this stage, the device sends data to the server using a communication method, and the server receives the user-entered data.

[0469] 2. Generative AI Scrutiny

[0470] The server passes the application details to the generation AI, which then scrutinizes the application details based on past data. The generation AI detects errors such as typos and incomplete data. This process uses an AI model and associated natural language processing libraries.

[0471] 3. Visualization and notification of error points

[0472] The error points detected by the generation AI are visualized by the server and notified to the user. The server visually represents the error points in an easy-to-understand format and provides them to the user through a notification system. The server also notifies the user of areas that need to be corrected and points that require attention.

[0473] 4. Emotional Data Collection and Analysis

[0474] While the user is interacting with the application, the emotion engine collects emotion data such as the user's facial expressions, tone of voice, and typing speed. This data is acquired through hardware such as a camera, microphone, and keyboard typing speed sensor. The emotion data is sent to the server and provided to the emotion engine.

[0475] 5. Analysis by Emotion Engine

[0476] The emotion engine analyzes the collected emotion data and recognizes the user's emotional state. The emotion engine's analysis results are provided to the generative AI via the server. This information is used to adjust the format and timing of feedback based on the user's emotional state.

[0477] 6. Feedback and Retraining

[0478] When the user corrects the error points and resubmits, the generation AI will re-examine the application to confirm whether the error has been resolved. The result will also be notified to the user via the server. The server will also collect feedback data and provide it to the generation AI for re-learning, thereby improving accuracy from the next time onwards.

[0479] Example prompt:

[0480] Example prompt for the generating AI:

[0481] "Analyze the quality report to detect if it contains errors based on the following patterns: typos, omissions, missing data. Quality report content: {quality report text}"

[0482] Example prompts for the emotion engine:

[0483] "Analyze emotional data such as your facial expressions, tone of voice, and typing speed to recognize when you're stressed or relaxed. Data value: {emotion data}"

[0484] According to the present invention, by examining the application content and providing feedback while taking into consideration the emotional state of the user, it is possible to reduce the burden on approvers and decision makers and to respond to users in a flexible and optimal manner.

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

[0486] Step 1:

[0487] The user uses the terminal to input the application details. The input data is sent from the terminal to the server by pressing the "Send" button. The input is sent to the server as text data.

[0488] Input: Application details (text data)

[0489] Output: Application details sent to the server

[0490] Specific actions: Enter the required information in the application form and click the submit button.

[0491] Step 2:

[0492] The server passes the request details received from the device to the generation AI, which then sends the request details to the generation AI model via an API for analysis.

[0493] Input: Application details sent to the server

[0494] Output: Application details sent to the generation AI

[0495] Specific operation: The server transfers the application details to the generation AI and sends an analysis request.

[0496] Step 3:

[0497] The generative AI model examines the application content and detects errors such as typos and incomplete data. The generative AI learns from past data and identifies error patterns.

[0498] Input: Application details (text data)

[0499] Output: Error points (list format)

[0500] Specific operation: The generation AI analyzes the application content and generates a list of detected error points.

[0501] Step 4:

[0502] The server receives the error points from the AI ​​generator and visually displays the errors to the user. The error points are notified to the user's device.

[0503] Input: Error points (list format)

[0504] Output: Notify the user of the error point

[0505] Specific operation: The server analyzes the error point and generates a message to notify the user.

[0506] Step 5:

[0507] The user corrects the application details and sends them again from the terminal to the server. The corrected data is also transferred to the server.

[0508] Input: Corrected application details

[0509] Output: Modifications sent to the server

[0510] Specific operation: The user corrects the error points and submits the application again.

[0511] Step 6:

[0512] The server passes the revised application details to the generation AI again for re-examination, and the generation AI checks whether the previous error has been resolved.

[0513] Input: Corrected application details

[0514] Output: Re-examination results (whether there are any errors)

[0515] Specific operation: The server forwards the revised application content to the generation AI and sends a re-examination request.

[0516] Step 7:

[0517] The server collects emotional data during user operations and provides it to the emotion engine, which analyzes data such as facial expressions, tone of voice, and input speed.

[0518] Input: Emotional data (facial expressions, tone of voice, typing speed)

[0519] Output: Emotional state (analysis results)

[0520] Specific operation: The server sends emotion data to the emotion engine and sends an analysis request.

[0521] Step 8:

[0522] The analysis results of the emotion engine are provided to the generation AI via the server, and the format and timing of feedback are adjusted based on the user's emotional state.

[0523] Input: Emotional state (analysis result)

[0524] Output: Regulated Feedback

[0525] How it works: The generative AI receives emotional state data and adjusts the format and timing of feedback.

[0526] Step 9:

[0527] The final inspection results are sent to the server and notified to the user. If the problem has been resolved, the application is approved. The feedback data is also stored as data for retraining the generation AI.

[0528] Input: Final review results, feedback data

[0529] Output: Notification to user, data for retraining

[0530] Specific operation: The server notifies the user of the final inspection results and provides the generation AI with data for re-learning.

[0531] Through these steps, the present invention provides a system that significantly reduces the burden on approvers and decision makers by effectively examining and providing feedback on application content while taking into account the user's emotional state.

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

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

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

[0535] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

[0546] In the smart glasses 214, 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.

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

[0548] This invention is a system that utilizes generation AI to approve or reject application content, reducing the burden on approvers and decision makers. The main components of this system are a terminal, a server, and generation AI.

[0549] Program processing

[0550] Data collection and learning

[0551] The server collects data such as past application details, approval / rejection history, and comments, and provides it to the generation AI.

[0552] Based on this data, the generative AI learns patterns such as typos and incomplete descriptions.

[0553] Acceptance and review of application details

[0554] The user (applicant) enters a new application into the form from the terminal and submits it.

[0555] The terminal transmits the input application details to the server.

[0556] The server receives the application data and passes it to the generation AI.

[0557] The generation AI scrutinizes the application content and detects errors such as typos and missing information.

[0558] Alerts and Notifications

[0559] The server identifies the areas to be corrected based on the error report from the generation AI and visualizes the error points.

[0560] The server notifies the users (applicant and approver) of any corrections or points to note.

[0561] Correct and resubmit

[0562] The user (applicant) corrects the application details on the terminal and resubmits it.

[0563] The terminal sends the corrected application details to the server again.

[0564] Re-examination and final confirmation

[0565] The server passes the resubmitted application data to the generation AI and conducts a re-examination.

[0566] The generating AI will re-examine it to make sure there are no problems.

[0567] Approval or rejection decision

[0568] The user (approver / decisor) checks the final error report to confirm that the corrections have been completed and approves or rejects the application.

[0569] Feedback and Retraining

[0570] The server collects feedback data and retrains the generating AI to improve accuracy in future generations.

[0571] Specific examples

[0572] For example, consider the process of applying for a business trip. An example will be explained in which a user inputs details such as the purpose of the business trip, schedule, and expenses from a terminal and submits the information.

[0573] The user (applicant) fills in the business trip application form and submits it.

[0574] The terminal sends the application details to the server.

[0575] The server passes the application data to the generation AI, which then examines the contents.

[0576] The generation AI detects errors such as "a typo in an expense item or an incomplete accommodation address."

[0577] The server sorts out the error points and notifies the users (applicant and approver).

[0578] The user (applicant) resubmits the corrected content.

[0579] The generating AI will re-examine the data to ensure that the problem has been resolved.

[0580] The user (approver / decisor) performs the final check and approves or rejects the application.

[0581] The server collects feedback and retrains the generative AI.

[0582] In this way, we aim to streamline the approval process for business trip applications and significantly reduce the burden on approvers and decision makers.

[0583] The processing flow will be explained below.

[0584] Step 1:

[0585] The user (applicant) enters a new application into the form from a terminal. The application contents include necessary information (e.g., name, purpose, schedule, expenses, etc.).

[0586] Step 2:

[0587] The terminal sends the entered application details to the server, which then receives the application data.

[0588] Step 3:

[0589] The server passes the received application data to the generation AI, which then begins the process of examining the application content.

[0590] Step 4:

[0591] The generation AI then scrutinizes the application, detecting errors such as typos, missing required fields, and inconsistent information.

[0592] Step 5:

[0593] The server receives the error report from the generation AI, identifies which part of the application content is problematic, and visualizes the error point.

[0594] Step 6:

[0595] The server notifies the user (applicant and approver) of the error and the corrections required. This notification is often done via email or dashboard.

[0596] Step 7:

[0597] The user (applicant) checks the error report and corrects the application content. The corrections include the errors identified by the generation AI.

[0598] Step 8:

[0599] The user (applicant) resends the revised application details from the terminal to the server.

[0600] Step 9:

[0601] The server passes the corrected application data to the generation AI again for re-examination. The generation AI then checks whether the previous error has been resolved.

[0602] Step 10:

[0603] The generation AI returns the results after re-examination to the server, and if the problem has been resolved, a report with no errors is provided.

[0604] Step 11:

[0605] The server notifies the user (approver / decisor) of the final error report, indicating whether the error has been resolved or whether a new error has occurred.

[0606] Step 12:

[0607] The user (approver / decisor) checks the application content based on the final error report and decides whether to approve or reject it.

[0608] Step 13:

[0609] Users (approvers and decision makers) enter their approval or rejection feedback into the system, which is important for future learning.

[0610] Step 14:

[0611] The server collects feedback and provides it to the generative AI as data for retraining, which improves accuracy in future iterations.

[0612] The above are the specific processing steps in the system of the present invention.

[0613] Example 1

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

[0615] In today's business environment, the time and effort required for the approval and rejection process for application content is a major challenge. In particular, frequent typos and incomplete descriptions require repeated corrections and resubmissions, placing a heavy burden on approvers and decision makers. Furthermore, technology that learns from past application data to improve the accuracy of review has not yet been fully established, preventing an efficient process. To address these challenges, a system is needed that efficiently reviews application content, notifies users, and provides guidance on how to make corrections.

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

[0617] In this invention, the server includes means for transmitting application content from a terminal to the server, means for the generation AI to learn from past data and scrutinize the application content, means for visualizing error points based on the generation AI's scrutiny results, means for notifying the user of the error points and correction details, means for collecting user feedback and having the generation AI re-learn, means for sending the application content to the server again and having the generation AI re-scrutinize it if the application content is corrected, and means for notifying the user (approver / decisor) of the re-scrutiny results and prompting them to make a final decision. This makes it possible to streamline the application content scrutiny and correction process and significantly reduce the burden on approvers and decision makers.

[0618] "Application content" refers to the data that a user inputs and submits via a terminal to request approval or authorization.

[0619] The "server" is a computer system that sends and receives application details, provides data to the generation AI, and visualizes and notifies error points.

[0620] "Generative AI" is an algorithm or model that learns patterns such as typos and incomplete descriptions based on past application data and then scrutinizes the application content.

[0621] "Error point" is a term that refers to the points where the generation AI detects problems such as typos or insufficient information after carefully examining the application content.

[0622] "User" refers to the applicant who inputs and submits the application details, and the approver / decisor who ultimately approves or rejects the application.

[0623] "Feedback" refers to the evaluations and comments regarding the application collected from users, as well as the results of approval or rejection.

[0624] "Relearning" is the process by which generative AI updates its model based on newly collected feedback data to improve its accuracy.

[0625] "Scrutiny" is a process in which the generation AI analyzes the application content in detail and detects errors such as typos and missing information.

[0626] "Notification" is a means of information transmission by the server to inform the user of the error point and the correction content.

[0627] "Re-examination" is a process in which the generation AI re-analyzes in detail the application content corrected by the user to confirm whether any errors detected previously have been resolved.

[0628] This invention is a system that aims to improve the efficiency of approving or rejecting application content, and mainly utilizes a server, terminals, and a generative AI model. This system uses past application data for the generative AI to learn and examine, reducing the burden on users.

[0629] Hardware and software used

[0630] This system uses the following hardware and software:

[0631] Server: A server machine for high-performance data processing. For example, we will use an AWS EC2 instance.

[0632] Device: A PC or mobile device used by applicants and approvers, using a web browser (such as Google Chrome or Mozilla Firefox).

[0633] Generative AI model: An AI model that learns from past data and scrutinizes application content. It uses TensorFlow and PyTorch.

[0634] Data processing and calculation

[0635] The operation of this system is as follows.

[0636] First, the server collects data such as past application details, approval / denial history, and comments, and provides it to the generation AI. The generation AI then learns from this collected data and creates a model that can identify patterns such as typos and incomplete descriptions.

[0637] Next, the user (applicant) enters the necessary information into the application form on their device and submits it. The device then sends this application data to the server, which then passes it on to the generation AI. The generation AI then carefully examines the application content and detects errors such as typos and missing information.

[0638] Based on the results of the generative AI's inspection, the server visualizes the error points and notifies the user of corrections and points to note. By receiving this notification, users (applicants and approvers) can be sure to understand which parts need to be corrected.

[0639] The user (applicant) then corrects any corrections and submits the data again. The server passes the corrected application data back to the generation AI, which then re-examines it. Once the server confirms that there are no problems, it sends a notification to the user (approver / decisor) for final confirmation.

[0640] Finally, the server collects feedback data and retrains the generative AI to improve accuracy in future iterations. By continuing this feedback process, the system is always adapting to the latest evaluation criteria, enabling more accurate scrutiny.

[0641] Specific examples

[0642] For example, to explain the process of applying for a business trip as a specific example, the user (applicant) enters details such as the purpose of the business trip, schedule, and expenses on a terminal and submits them. The application data is sent to the server, and the generation AI detects errors such as "a typographical error in the expense item or an incomplete accommodation address." The server sorts out the error points and notifies the users (applicant and approver). The user resubmits the corrected content, and the generation AI re-examines it. After confirming that the problem has been resolved, the user (approver / decisor) makes a final check and approves or rejects the application. The server collects feedback and allows the generation AI to re-learn.

[0643] Prompt Sentence Examples

[0644] "What should I pay attention to when filling out a business trip application?"

[0645] "I want to learn about common mistakes made in past applications."

[0646] Please provide a detailed explanation as to why your application was rejected.

[0647] In this way, we aim to streamline the approval process for business trip applications and significantly reduce the burden on approvers and decision makers.

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

[0649] Step 1:

[0650] The server collects data such as past application details, approval / rejection history, and comments.

[0651] Specific operation: The server connects to the business management system database and extracts travel request data from the past year using an SQL query.

[0652] Input: Historical data from business management systems

[0653] Output: Past application data extracted from the database

[0654] Step 2:

[0655] The server provides the collected data to the generation AI.

[0656] Specific operation: The server converts the extracted data into JSON format and sends it to the generative AI's learning module using an HTTP request.

[0657] Input: Extracted past application data

[0658] Output: Training data sent to the generation AI

[0659] Step 3:

[0660] The generative AI learns patterns such as typos and incomplete descriptions based on the data provided.

[0661] What it does: Generative AI uses the data you send it to identify patterns of typos, omissions, and imperfections and trains a neural network model.

[0662] Input: Past application data including typos and incomplete descriptions

[0663] Output: A trained generative AI model

[0664] Step 4:

[0665] The user (applicant) enters a new application into the form from the terminal and submits it.

[0666] Specific operation: The user fills in the necessary information in the travel request form on the browser and clicks the submit button.

[0667] Input: Application information entered by the user into the form

[0668] Output: Application data sent from the terminal

[0669] Step 5:

[0670] The terminal transmits the input application details to the server.

[0671] Specific operation: The terminal converts the input content into XML format and sends it to the server using SSL.

[0672] Input: Application data from the form

[0673] Output: Request data sent to the server

[0674] Step 6:

[0675] The server receives the application data and passes it to the generation AI.

[0676] Specific operation: The server sends the received application data to the generation AI's inspection module.

[0677] Input: Application data sent from the terminal

[0678] Output: Application data sent to the generation AI

[0679] Step 7:

[0680] The generation AI scrutinizes the application content and detects errors such as typos and missing information.

[0681] Specific operation: The generation AI analyzes the application data and detects errors such as "a typo in the expense item" or "an incomplete address for the accommodation."

[0682] Input: Application data

[0683] Output: Error report

[0684] Step 8:

[0685] The server identifies the areas to be corrected based on the error report from the generated AI and visualizes the error points.

[0686] Specific operation: The server analyzes the error report from the generated AI and highlights the error point in red on the web interface.

[0687] Input: Error report from the generation AI

[0688] Output: Visualized error points

[0689] Step 9:

[0690] The server notifies the users (applicant and approver) of any corrections or points to note.

[0691] Specific operation: The server uses the email notification system to send detailed emails including the error point to the applicant and approver.

[0692] Input: Visualized error points

[0693] Output: Notification email showing corrections and points to note

[0694] Step 10:

[0695] The user (applicant) corrects the application details on the terminal and resubmits it.

[0696] Specific actions: The user checks the error email, corrects the indicated items on the form, and clicks the resubmit button.

[0697] Input: Corrected application data

[0698] Output: Resubmitted application data

[0699] Step 11:

[0700] The terminal sends the corrected application details to the server again.

[0701] Specific operation: The terminal re-enters the data and sends it to the server.

[0702] Input: Corrected application data

[0703] Output: Request data resubmitted to the server

[0704] Step 12:

[0705] The server passes the resubmitted application data to the generation AI and conducts a re-examination.

[0706] Specific operation: The server updates the corrected application data and transfers it again to the generation AI's inspection module.

[0707] Input: Resubmitted application data

[0708] Output: Data resubmitted to the generating AI

[0709] Step 13:

[0710] The generating AI will re-examine it to make sure there are no problems.

[0711] Specific behavior: The generation AI analyzes the data again and generates a final error report.

[0712] Input: Resubmitted application data

[0713] Output: Error report of re-examination results

[0714] Step 14:

[0715] The user (approver / decisor) checks the final error report to confirm that the corrections have been completed and approves or rejects the application.

[0716] Specific operation: The approver checks the error report and clicks the approve or reject button on the system.

[0717] Input: Error report of re-examination results

[0718] Output: Approval or rejection decision

[0719] Step 15:

[0720] The server collects feedback data and retrains the generating AI to improve accuracy in future generations.

[0721] Specific operation: The server records the approval / denial results in a database and periodically reflects them in the learning module of the generation AI.

[0722] Input: Approval / Rejection result feedback

[0723] Output: Retrained generative AI model

[0724] (Application example 1)

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

[0726] At logistics centers, when workers replenish inventory or submit various applications, typographical errors or insufficient information in the application content can delay the approval process and reduce work efficiency. Another problem is the burden placed on approvers and decision makers when processing a huge number of applications. To solve these issues, a system is needed that streamlines the review and revision of application content and speeds up the approval process.

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

[0728] In this invention, the server includes means for transmitting application content from an information processing device to a database server, means for a generation AI to learn past data and analyze the application content, means for visualizing error points based on the analysis results of the generation AI, means for notifying an operator of the error points and correction details, means for collecting operator feedback and having the generation AI re-learn, means for an operator to input and correct the application content by voice input or gesture using smart glasses, and means for approving or rejecting the application content via the smart glasses. This makes it possible to quickly detect and correct errors in the application content and streamline the approval process.

[0729] An "information processing device" is a device for data entry, calculation, and information processing.

[0730] A "database server" is a server that centrally stores data and allows multiple users to access it via a network.

[0731] "Generative AI" is a type of artificial intelligence model that can learn from large amounts of data and apply it to new data.

[0732] "Visualization" is the process of making data and information easier to understand by displaying them in a visual format such as a graph or chart.

[0733] "Operator" means a person or device whose role is to operate and manage a machine or system.

[0734] "Smart glasses" are glasses-type devices equipped with displays and sensors that provide functions such as augmented reality and voice input.

[0735] "Voice input" is a technology or method for recognizing a person's voice and converting that speech into text or commands.

[0736] "Gestures" refer to giving instructions or performing operations using hand or body movements.

[0737] "Application" means the details of a formal request or proposal submitted for a specific purpose.

[0738] "Analysis" is the process of breaking down data or information to understand its structure and meaning.

[0739] An "approval process" is a series of procedures that review submitted applications and requests and determine whether to approve them.

[0740] "Feedback" is information about evaluations and reactions to a system or process, which can lead to improvements or adjustments.

[0741] "Retraining" means that generative AI uses new data and feedback to train the model again in order to improve its accuracy and performance.

[0742] This invention is a system for streamlining application processes at logistics centers, and in particular supports the review and approval of application contents for inventory replenishment, etc. The system's main components are an information processing device, a database server, a generation AI, and smart glasses.

[0743] System configuration and operation

[0744] 1. Hardware and Software Used

[0745] Information processing devices: smart glasses (e.g., Google Glass Enterprise Edition 2)

[0746] Database server: High-performance computing server, AWS (Amazon Web Services) infrastructure

[0747] Generated AI: OpenAI GPT-4 API

[0748] Text analysis library: SpaCy

[0749] 2. Data collection and learning

[0750] The server stores data such as past inventory requests, approval / denial history, and comments in an AWS RDS database. This data is provided to OpenAI GPT-4, which learns patterns of typos and incomplete descriptions. This improves the generative AI's ability to efficiently review requests.

[0751] 3. Acceptance and review of application details

[0752] Using smart glasses, workers input new requests (e.g., "I would like to request a replenishment of stock for Type III materials on the next shelf X. The current stock quantity is 10.") into a form using voice input or gestures, and then send the request to the server via the smart glasses. The server then passes the request details to the generation AI via AWS's closed API, and the AI ​​detects errors such as typos and missing information.

[0753] 4. Warnings and Notifications

[0754] The server receives the error report from the AI ​​generator and visualizes the error points based on the report. The visualized error points and points of caution are then notified to the worker via the smart glasses display.

[0755] 5. Corrections and resubmissions

[0756] Workers can use voice input or gestures through the smart glasses to amend the application details, which are then sent back to the server and passed to the AI ​​for further review.

[0757] 6. Re-examination and final confirmation

[0758] The server then uses the AI ​​to analyze the resubmitted application data and check whether the problems have been resolved. If all errors have been corrected, the server notifies the worker via the smart glasses.

[0759] 7. Decision on Approval or Rejection

[0760] The logistics center manager uses the smart glasses to approve or reject the application based on the final error report, thereby completing the application process.

[0761] 8. Feedback and Retraining

[0762] The server collects feedback data on approvals and denials and retrains the generating AI, improving accuracy from the next time onwards.

[0763] Specific examples

[0764] For example, consider a worker speaking the following prompt into smart glasses:

[0765] "I would like to request a replenishment of the next shelf, X, of Type III materials. The current stock quantity is 10."

[0766] The generative AI converts speech to text and analyzes the application to detect error points such as:

[0767] "There is a typo in your inventory replenishment request. Please check again."

[0768] Workers can make corrections and resubmit through the smart glasses, streamlining the application process.

[0769] Example prompt sentence:

[0770] Stock replenishment request:

[0771] Shelf: X

[0772] Product name: III type material

[0773] Currently in stock: 10

[0774] Is there a typo or incompleteness in the above content? Please provide detailed feedback.

[0775] As described above, the present invention is a practical system that significantly improves work efficiency by combining generative AI and smart glasses.

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

[0777] Step 1:

[0778] The server collects and stores data such as past inventory requests, approval / denial history, and comments in an AWS RDS database. This prepares a dataset for the generative AI to learn from. The input is past inventory request data, and the output is the prepared dataset.

[0779] Step 2:

[0780] The server provides the collected dataset to the generative AI (OpenAI GPT-4 API). The generative AI uses this to learn patterns of typos and incomplete descriptions. The input is past inventory request data, and the output is the trained generative AI model. Specifically, the dataset is sent in JSON format to the generative AI API, and the model is trained.

[0781] Step 3:

[0782] The user (worker) uses the smart glasses to input new application details using voice input or gestures. The input is the application details as voice, and the output is the application details converted to text. The smart glasses' microphone and voice recognition software are used to convert the voice to text.

[0783] Step 4:

[0784] The terminal (smart glasses) sends the textual application details to a database server. The input is the textual application details, and the output is the application data stored on the server.

[0785] Step 5:

[0786] The server passes the received application data to the generation AI for scrutiny. The generation AI analyzes the application content and detects errors such as typos and insufficient information. The input is the text version of the application content, and the output is an error report. Specifically, the application data is sent to the generation AI API and the analysis results are obtained.

[0787] Step 6:

[0788] The server visualizes the error points based on the error report from the generation AI. The input is the error report, and the output is the visualized error points. Specifically, it generates text highlighting the error points and sends it to the smart glasses.

[0789] Step 7:

[0790] The user (worker) checks the error points through the smart glasses and corrects the application details using voice input or gestures. The input is the visualized error points and voice input, and the output is the corrected application details.

[0791] Step 8:

[0792] The terminal (smart glasses) sends the corrected application details back to the database server. The input is the corrected application details, and the output is the corrected application data stored on the server.

[0793] Step 9:

[0794] The server passes the resubmitted application data to the generation AI for re-examination. The generation AI analyzes the application again and checks whether the problem has been resolved. The input is the corrected application content, and the output is the final error report.

[0795] Step 10:

[0796] The server confirms that the correction is complete based on the final error report and notifies the worker of this via the smart glasses. The input is the final error report, and the output is the approval notification.

[0797] Step 11:

[0798] The user (logistics center manager) uses the smart glasses to perform the final approval or rejection of the application. The input is the approval notification, and the output is the approval or rejection decision.

[0799] Step 12:

[0800] The server collects feedback data on approvals and denials and retrains the generative AI. The input is the feedback data, and the output is an even more accurate generative AI model.

[0801] This processing flow makes it possible to quickly detect and correct errors in application content and streamline the approval process.

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

[0803] This invention is a system that utilizes generative AI to approve or reject application content, and also combines it with an emotion engine that recognizes user emotions, with the aim of reducing the burden on approvers and decision makers. This section explains the specific components and processing flow of this system.

[0804] Program processing

[0805] Data collection and learning

[0806] The server collects data such as past application details, approval / rejection history, and comments, and provides it to the generation AI.

[0807] Based on this data, the generative AI learns patterns such as typos and incomplete descriptions.

[0808] Acceptance and review of application details

[0809] The user (applicant) enters a new application into the form from the terminal and submits it.

[0810] The terminal transmits the input application details to the server.

[0811] The server receives the application data and passes it to the generation AI.

[0812] The generation AI scrutinizes the application content and detects errors such as typos and missing information.

[0813] Alerts and Notifications

[0814] The server identifies the areas to be corrected based on the error report from the generation AI and visualizes the error points.

[0815] The server notifies the users (applicant and approver) of any corrections or points to note.

[0816] Emotion data collection and analysis

[0817] The emotion engine collects emotional data (e.g., facial expressions, tone of voice, input speed, etc.) when users (applicants and approvers) operate the system.

[0818] The server provides the emotion data collected from the emotion engine to the generation AI for analysis.

[0819] Correct and resubmit

[0820] The user (applicant) checks the error report and corrects the application content. The corrections include the errors identified by the generation AI.

[0821] The terminal sends the corrected application details to the server again.

[0822] Re-examination and final confirmation

[0823] The server passes the corrected application data to the generation AI again for re-examination. The generation AI then checks whether the previous error has been resolved.

[0824] The generation AI returns the results after re-examination to the server, and if the problem has been resolved, a report with no errors is provided.

[0825] Approval or rejection decision

[0826] The user (approver / decisor) checks the application contents based on the final error report and decides whether to approve or reject it.

[0827] The emotion engine recognizes the emotions that approvers and decision makers feel when making decisions and adjusts the form of feedback as needed.

[0828] Feedback and Retraining

[0829] The server collects feedback data and provides it to the generation AI as data for re-learning, which improves accuracy in future iterations.

[0830] The generative AI also learns from emotional data to optimize future notification processes and feedback methods.

[0831] Specific examples

[0832] For example, the approval process for a new project proposal may involve the following steps: Let us consider an example in which a user inputs and submits a project proposal from a terminal.

[0833] The user (applicant) fills out the project proposal form and submits it.

[0834] The terminal transmits the input proposal to the server.

[0835] The server passes the proposal data to the generation AI, which then scrutinizes the content, detecting typos and missing data.

[0836] The emotion engine recognizes the user's emotions and detects, for example, if the user is in a hurry or stressed.

[0837] The server visualizes the error point and notifies the user (applicant and approver).

[0838] The user (submitter) makes corrections and resubmits. The emotion engine also evaluates the user's state at the time of resubmission.

[0839] The generating AI will re-examine the data to ensure that the problem has been resolved.

[0840] The user (approver / decisor) makes a final check and approves or rejects the proposal. The emotion engine recognizes the emotion at the time of decision and adjusts the feedback format accordingly.

[0841] The server collects feedback and retrains the generative AI, optimizing the process for future iterations.

[0842] In this way, the present invention not only improves the efficiency of the application process, but also enables flexible responses according to the emotional state of the user, thereby significantly reducing the burden on approvers and decision makers.

[0843] The processing flow will be explained below.

[0844] Step 1:

[0845] The user (applicant) enters a new application into the form from a terminal. The application contents include necessary information (e.g., name, purpose, schedule, expenses, etc.).

[0846] Step 2:

[0847] The terminal sends the input application content and emotional data (e.g., facial expressions, tone of voice, input speed, etc.) during the user's operation to the server. The emotional data is collected by the emotion engine.

[0848] Step 3:

[0849] The server passes the received application data and emotion data to the generation AI, which then begins the process of examining the application content and analyzing the emotion data simultaneously.

[0850] Step 4:

[0851] The generative AI then scrutinizes the application, detecting errors such as typos, missing required fields, and inconsistent information, and also analyzes emotional data to assess the user's state.

[0852] Step 5:

[0853] The server receives the error report and sentiment analysis results from the AI ​​generation, identifies which part of the application content has a problem, and visualizes the error point. The sentiment analysis results are also included in the report.

[0854] Step 6:

[0855] The server notifies users (applicants and approvers) of the error points and corrections. The notification method is adjusted according to the user's emotional state (e.g., if the user is feeling stressed, the notification will be in gentle language).

[0856] Step 7:

[0857] The user (applicant) checks the error report and emotional advice and corrects the application. The corrections include the errors identified by the generation AI.

[0858] Step 8:

[0859] The user (applicant) resends the revised application details from the terminal to the server. At the same time, the emotion engine collects the user's emotion data again at the time of resending.

[0860] Step 9:

[0861] The server passes the corrected application data and emotion data to the generation AI again for re-examination. The generation AI then checks whether the previous error has been resolved.

[0862] Step 10:

[0863] The generative AI then returns the results to the server after further review. If the problem has been resolved, it will provide an error-free report. At the same time, it also analyzes emotional data to evaluate the user's state.

[0864] Step 11:

[0865] The server notifies the user (approver / decisor) of the final error report and the result of the sentiment analysis. The content of the notification is adjusted based on the user's emotional state.

[0866] Step 12:

[0867] The user (approver / decisor) checks the application content based on the final error report and decides whether to approve or reject it. The emotion engine recognizes the emotions of the approver / decisor when making the decision and adjusts the feedback format as necessary.

[0868] Step 13:

[0869] Users (approvers and decision makers) enter their approval or rejection feedback into the system, which is important for future learning.

[0870] Step 14:

[0871] The server collects feedback and provides it to the generative AI as retraining data, which includes emotional data to optimize future processing.

[0872] The above are the specific processing steps in the system of the present invention. Through this flow, it is possible to streamline the application process while taking into account the emotional state of the user, and significantly reduce the burden on approvers and decision makers.

[0873] Example 2

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

[0875] In the conventional application process, detecting and correcting typos and missing information requires a great deal of time and effort. It also places a heavy psychological burden on approvers and decision makers when they review application documents. Furthermore, while flexible responses based on user emotions are required, this is not being fully implemented. As a result, the entire application process is inefficient, resulting in a poor user experience.

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

[0877] In this invention, the server includes means for transmitting application content from the terminal to the server, means for the server to collect past application data and provide it to the generation AI, means for the generation AI to learn about typos and incomplete descriptions based on the past data and scrutinize the application content, means for visualizing error points based on the generation AI's scrutiny results, means for notifying the user of the error points and corrections, means for the emotion engine to collect user emotion data and provide it to the generation AI, means for re-sending application content corrected by the user to the server and re-scrutinizing it, and means for collecting user feedback and having the generation AI re-learn. This makes it possible to quickly and accurately detect typos and insufficient information and provide flexible feedback according to the user's psychological state.

[0878] 1. "Submission" means any document or information submitted by a User and sent to the Server for a specific purpose, such as proposing a new project or applying for rights.

[0879] 2. "Device" refers to the electronic device used by the user to input and submit application details, including personal computers, smartphones, tablets, etc.

[0880] 3. "Server" refers to the central processing unit that receives the application details sent from the terminal and processes and analyzes the data in cooperation with the generation AI and emotion engine.

[0881] 4. "Generative AI" refers to automated artificial intelligence models that learn from past data and scrutinize applications for typos and incomplete descriptions. For example, they use natural language processing technology to analyze documents.

[0882] 5. "Error points" are typos or missing information detected by the generation AI when examining the application content, and are visualized to prompt the user to make corrections.

[0883] 6. "Emotion engine" refers to technology that collects emotional data from a user's facial expressions, tone of voice, input speed, etc., and recognizes the user's psychological state.

[0884] 7. "Feedback" refers to response information that notifies the user of the results of the generative AI's inspection and information on error points, allowing the user to make corrections based on that information.

[0885] 8. "Retraining" is the process by which the system retrains the generative AI based on newly collected data and user feedback to improve accuracy and efficiency in future generations.

[0886] MODE FOR CARRYING OUT THE INVENTION

[0887] This invention is a system that realizes efficient application processes and flexible responses according to the user's emotional state. This system consists of a terminal, a server, a generation AI, and an emotion engine. The specific functions of each component and their execution procedures are explained below.

[0888] Hardware and software used

[0889] Terminal: Electronic device used by the user to input and submit application details. Examples include personal computers, smartphones, and tablets.

[0890] Server: A central processing unit that receives the application details and processes and analyzes the data in cooperation with the generative AI and emotion engine.

[0891] Generative AI: An automated artificial intelligence model that learns from historical data to refine applications, using natural language processing techniques such as GPT-4.

[0892] Emotion engine: Dedicated software and hardware for analyzing a user's facial expressions, tone of voice, and typing speed to collect emotional data.

[0893] Specific operation explanation

[0894] 1. Acceptance of application details

[0895] The user opens an application form on their device and enters the details of the application, such as a new project proposal or rights application. Once the input is complete, they press the send button to send the data to the server. At this time, the device sends the data securely using the HTTPS protocol.

[0896] 2. Receipt and provision of data

[0897] The server receives the application details sent from the device. At the same time, the server accesses the company's database to collect past application details and approval / denial history, and provides this information to the generation AI. This allows the generation AI to learn from past patterns and improve the accuracy of detecting typos and missing information.

[0898] 3. Review of application details

[0899] The generation AI analyzes the received application content and detects typos and missing information. For example, if there are any typos, it will identify them and also present any required information that is missing from the application content.

[0900] 4. Visualization and notification of error points

[0901] The server visualizes the error points in the application based on the error report returned by the generation AI. Specifically, it highlights the error points in red and notifies the user with instructions to correct them. This notification is sent via email or within the system.

[0902] 5. Emotional Data Collection and Analysis

[0903] The emotion engine collects facial expressions, tone of voice, and input speed in real time when the user edits the application. This emotional data is sent to the server and provided to the generation AI. Based on this data, the generation AI analyzes the user's psychological state, such as whether they are feeling stressed.

[0904] 6. Re-examination and final confirmation

[0905] After the user has completed the corrections, they send the application details back to the server. The server then provides the data to the generation AI again and re-examines it. If the errors have been resolved, a report of the correct status is returned, and the approver makes a final confirmation.

[0906] 7. Feedback and Retraining

[0907] The approver reviews the final error report and makes a decision to approve or reject it. At the same time, the emotion engine analyzes the approver's emotions and adjusts the feedback format as necessary. The server collects the feedback data and retrains the generation AI to further improve accuracy in future iterations.

[0908] Examples of specific examples and prompts

[0909] For example, the approval process for a new project proposal may involve the following steps: Let us consider an example in which a user inputs and submits a project proposal from a terminal.

[0910] 1. Review the project proposal

[0911] "You have entered a new project proposal. Please check for typos and missing information."

[0912] 2. Generate an error report

[0913] "Please create an error report for this project proposal and point out any corrections that need to be made."

[0914] 3. Emotion Data Analysis

[0915] "Analyze whether the user is feeling stressed or not from facial expression data."

[0916] This allows the system to streamline the application process and respond flexibly to the user's emotional state.

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

[0918] Program processing flow

[0919] Step 1:

[0920] Input: A user opens an application form on their device and enters details of an application, such as a new project proposal or rights application.

[0921] Specific operation: The user enters the required information into the form on the terminal and presses the submit button.

[0922] Output: Input data is sent from the device to the server.

[0923] Step 2:

[0924] Input: Application details sent from the terminal

[0925] Specific operation: The server receives data from the device and saves the application details. At the same time, it accesses the company's database to collect past application data and approval / denial history, and provides this information to the generation AI.

[0926] Output: Saved application data and learning data used by the generation AI

[0927] Step 3:

[0928] Input: Past data and new application details provided by the server

[0929] How it works: The generation AI uses natural language processing technology to learn patterns of typos and incomplete descriptions based on past data and then scrutinize the content of new applications.

[0930] Output: Results of review of new application (error report)

[0931] Step 4:

[0932] Input: The inspection result (error report) returned by the generation AI

[0933] Specific operation: The server receives the error report from the generation AI and visualizes the error points. Specifically, it highlights typos and missing information in red and generates correction instructions.

[0934] Output: A visualized error report

[0935] Step 5:

[0936] Input: A visualized error report

[0937] What happens: The server will send a notification to the user containing the error and instructions on how to fix it. This notification can be done via email or an in-system notification.

[0938] Output: Notification of fix to user

[0939] Step 6:

[0940] Input: Facial expressions, tone of voice, typing speed, etc. when users operate the system

[0941] Specific operation: The emotion engine collects the user's emotion data and sends it to the server. The emotion engine collects data using the camera and microphone.

[0942] Output: Emotion data

[0943] Step 7:

[0944] Input: Emotion data sent from the emotion engine

[0945] Specific operation: The server provides emotional data to the generation AI via an analysis API. The generation AI analyzes this emotional data and determines the user's psychological state.

[0946] Output: Psychological state as a result of analysis

[0947] Step 8:

[0948] Input: Application details for which corrections have been notified

[0949] Specific operation: The user corrects the application details based on the error report and presses the submit button again, which causes the corrected data to be resent to the server.

[0950] Output: Corrected application data

[0951] Step 9:

[0952] Input: Corrected application data

[0953] Specific operation: The server provides the correction data to the generation AI again and performs a re-examination. The generation AI checks whether the previous error has been resolved.

[0954] Output: Re-examination result (determining whether the issue has been resolved)

[0955] Step 10:

[0956] Input: Re-examination results

[0957] Specific operation: The server provides the re-examination results to the approver, who makes a final decision based on the error report and the re-examination results.

[0958] Output: Approval or rejection decision

[0959] Step 11:

[0960] Input: Approver's final decision and feedback

[0961] How it works: The server collects feedback and provides it to the generation AI as retraining data, which allows the generation AI to improve its accuracy in future generations.

[0962] Output: Data for retraining

[0963] (Application example 2)

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

[0965] Conventional application review systems using generative AI provide uniform feedback without considering the user's emotional state, which can lead to increased stress and dissatisfaction. Furthermore, the application of review results is not flexible and does not take into account the user's emotions, which increases the burden on approvers and decision makers. The present invention aims to solve these problems.

[0966] 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 for transmitting application content from a terminal to the server, means for the generation AI to learn past data and scrutinize the application content, means for visualizing error points based on the generation AI's scrutiny results, means for notifying the user of the error points and correction details, means for collecting user emotion data and providing it to the emotion engine, means for the emotion engine to analyze the user emotion data and provide the analysis results to the generation AI, and means for collecting user feedback and having the generation AI re-learn. This enables the generation AI to take the user's emotional state into consideration and provide optimal feedback, while also reducing the burden on approvers and decision makers.

[0967] "Application content" refers to the data and information that the user sends to the server.

[0968] "Terminal" refers to an input device used by a user, and includes PCs, tablets, smartphones, etc.

[0969] A "server" is a central computer system that collects, processes, and stores data.

[0970] "Generative AI" is an artificial intelligence system that learns from past data and scrutinizes application content and detects errors.

[0971] "Error points" refer to problematic areas such as typos, omissions, and deficiencies that the generation AI detects in the application content.

[0972] "Visualization" refers to displaying data or information visually to make it easier for users to understand.

[0973] "Emotion data" refers to information such as the user's facial expression, tone of voice, and input speed, and is data used by the emotion engine for analysis.

[0974] The "emotion engine" is a system that analyzes the user's emotional data and recognizes and evaluates their emotional state.

[0975] "Feedback" refers to information that provides a user with notice or instructions regarding error points and corrections.

[0976] "Retraining" refers to the process by which generative AI retrains itself based on new data and feedback to improve its accuracy.

[0977] The present invention is a system that combines generative AI and an emotion engine to approve or reject application content. The specific components and operating procedures for realizing this system are described below.

[0978] The system configuration consists of a terminal, a server, a generative AI, an emotion engine, and a means of communication to link them together.

[0979] 1. Enter and submit your application details

[0980] The user enters the application details from a device (PC, tablet, smartphone, etc.). After input, the application details are sent from the device to the server. At this stage, the device sends data to the server using a communication method, and the server receives the user-entered data.

[0981] 2. Generative AI Scrutiny

[0982] The server passes the application details to the generation AI, which then scrutinizes the application details based on past data. The generation AI detects errors such as typos and incomplete data. This process uses an AI model and associated natural language processing libraries.

[0983] 3. Visualization and notification of error points

[0984] The error points detected by the generation AI are visualized by the server and notified to the user. The server visually represents the error points in an easy-to-understand format and provides them to the user through a notification system. The server also notifies the user of areas that need to be corrected and points that require attention.

[0985] 4. Emotional Data Collection and Analysis

[0986] While the user is interacting with the application, the emotion engine collects emotion data such as the user's facial expressions, tone of voice, and typing speed. This data is acquired through hardware such as a camera, microphone, and keyboard typing speed sensor. The emotion data is sent to the server and provided to the emotion engine.

[0987] 5. Analysis by Emotion Engine

[0988] The emotion engine analyzes the collected emotion data and recognizes the user's emotional state. The emotion engine's analysis results are provided to the generative AI via the server. This information is used to adjust the format and timing of feedback based on the user's emotional state.

[0989] 6. Feedback and Retraining

[0990] When the user corrects the error points and resubmits, the generation AI will re-examine the application to confirm whether the error has been resolved. The result will also be notified to the user via the server. The server will also collect feedback data and provide it to the generation AI for re-learning, thereby improving accuracy from the next time onwards.

[0991] Example prompt:

[0992] Example prompt for the generating AI:

[0993] "Analyze the quality report to detect if it contains errors based on the following patterns: typos, omissions, missing data. Quality report content: {quality report text}"

[0994] Example prompts for the emotion engine:

[0995] "Analyze emotional data such as your facial expressions, tone of voice, and typing speed to recognize when you're stressed or relaxed. Data value: {emotion data}"

[0996] According to the present invention, by examining the application content and providing feedback while taking into consideration the emotional state of the user, it is possible to reduce the burden on approvers and decision makers and to respond to users in a flexible and optimal manner.

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

[0998] Step 1:

[0999] The user uses the terminal to input the application details. The input data is sent from the terminal to the server by pressing the "Send" button. The input is sent to the server as text data.

[1000] Input: Application details (text data)

[1001] Output: Application details sent to the server

[1002] Specific actions: Enter the required information in the application form and click the submit button.

[1003] Step 2:

[1004] The server passes the request details received from the device to the generation AI, which then sends the request details to the generation AI model via an API for analysis.

[1005] Input: Application details sent to the server

[1006] Output: Application details sent to the generation AI

[1007] Specific operation: The server transfers the application details to the generation AI and sends an analysis request.

[1008] Step 3:

[1009] The generative AI model examines the application content and detects errors such as typos and incomplete data. The generative AI learns from past data and identifies error patterns.

[1010] Input: Application details (text data)

[1011] Output: Error points (list format)

[1012] Specific operation: The generation AI analyzes the application content and generates a list of detected error points.

[1013] Step 4:

[1014] The server receives the error points from the AI ​​generator and visually displays the errors to the user. The error points are notified to the user's device.

[1015] Input: Error points (list format)

[1016] Output: Notify the user of the error point

[1017] Specific operation: The server analyzes the error point and generates a message to notify the user.

[1018] Step 5:

[1019] The user corrects the application details and sends them again from the terminal to the server. The corrected data is also transferred to the server.

[1020] Input: Corrected application details

[1021] Output: Modifications sent to the server

[1022] Specific operation: The user corrects the error points and submits the application again.

[1023] Step 6:

[1024] The server passes the revised application details to the generation AI again for re-examination, and the generation AI checks whether the previous error has been resolved.

[1025] Input: Corrected application details

[1026] Output: Re-examination results (whether there are any errors)

[1027] Specific operation: The server forwards the revised application content to the generation AI and sends a re-examination request.

[1028] Step 7:

[1029] The server collects emotional data during user operations and provides it to the emotion engine, which analyzes data such as facial expressions, tone of voice, and input speed.

[1030] Input: Emotional data (facial expressions, tone of voice, typing speed)

[1031] Output: Emotional state (analysis results)

[1032] Specific operation: The server sends emotion data to the emotion engine and sends an analysis request.

[1033] Step 8:

[1034] The analysis results of the emotion engine are provided to the generation AI via the server, and the format and timing of feedback are adjusted based on the user's emotional state.

[1035] Input: Emotional state (analysis result)

[1036] Output: Regulated Feedback

[1037] How it works: The generative AI receives emotional state data and adjusts the format and timing of feedback.

[1038] Step 9:

[1039] The final inspection results are sent to the server and notified to the user. If the problem has been resolved, the application is approved. The feedback data is also stored as data for retraining the generation AI.

[1040] Input: Final review results, feedback data

[1041] Output: Notification to user, data for retraining

[1042] Specific operation: The server notifies the user of the final inspection results and provides the generation AI with data for re-learning.

[1043] Through these steps, the present invention provides a system that significantly reduces the burden on approvers and decision makers by effectively examining and providing feedback on application content while taking into account the user's emotional state.

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

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

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

[1047] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1060] This invention is a system that utilizes generation AI to approve or reject application content, reducing the burden on approvers and decision makers. The main components of this system are a terminal, a server, and generation AI.

[1061] Program processing

[1062] Data collection and learning

[1063] The server collects data such as past application details, approval / rejection history, and comments, and provides it to the generation AI.

[1064] Based on this data, the generative AI learns patterns such as typos and incomplete descriptions.

[1065] Acceptance and review of application details

[1066] The user (applicant) enters a new application into the form from the terminal and submits it.

[1067] The terminal transmits the input application details to the server.

[1068] The server receives the application data and passes it to the generation AI.

[1069] The generation AI scrutinizes the application content and detects errors such as typos and missing information.

[1070] Alerts and Notifications

[1071] The server identifies the areas to be corrected based on the error report from the generation AI and visualizes the error points.

[1072] The server notifies the users (applicant and approver) of any corrections or points to note.

[1073] Correct and resubmit

[1074] The user (applicant) corrects the application details on the terminal and resubmits it.

[1075] The terminal sends the corrected application details to the server again.

[1076] Re-examination and final confirmation

[1077] The server passes the resubmitted application data to the generation AI and conducts a re-examination.

[1078] The generating AI will re-examine it to make sure there are no problems.

[1079] Approval or rejection decision

[1080] The user (approver / decisor) checks the final error report to confirm that the corrections have been completed and approves or rejects the application.

[1081] Feedback and Retraining

[1082] The server collects feedback data and retrains the generating AI to improve accuracy in future generations.

[1083] Specific examples

[1084] For example, consider the process of applying for a business trip. An example will be explained in which a user inputs details such as the purpose of the business trip, schedule, and expenses from a terminal and submits the information.

[1085] The user (applicant) fills in the business trip application form and submits it.

[1086] The terminal sends the application details to the server.

[1087] The server passes the application data to the generation AI, which then examines the contents.

[1088] The generation AI detects errors such as "a typo in an expense item or an incomplete accommodation address."

[1089] The server sorts out the error points and notifies the users (applicant and approver).

[1090] The user (applicant) resubmits the corrected content.

[1091] The generating AI will re-examine the data to ensure that the problem has been resolved.

[1092] The user (approver / decisor) performs the final check and approves or rejects the application.

[1093] The server collects feedback and retrains the generative AI.

[1094] In this way, we aim to streamline the approval process for business trip applications and significantly reduce the burden on approvers and decision makers.

[1095] The processing flow will be explained below.

[1096] Step 1:

[1097] The user (applicant) enters a new application into the form from a terminal. The application contents include necessary information (e.g., name, purpose, schedule, expenses, etc.).

[1098] Step 2:

[1099] The terminal sends the entered application details to the server, which then receives the application data.

[1100] Step 3:

[1101] The server passes the received application data to the generation AI, which then begins the process of examining the application content.

[1102] Step 4:

[1103] The generation AI then scrutinizes the application, detecting errors such as typos, missing required fields, and inconsistent information.

[1104] Step 5:

[1105] The server receives the error report from the generation AI, identifies which part of the application content is problematic, and visualizes the error point.

[1106] Step 6:

[1107] The server notifies the user (applicant and approver) of the error and the corrections required. This notification is often done via email or dashboard.

[1108] Step 7:

[1109] The user (applicant) checks the error report and corrects the application content. The corrections include the errors identified by the generation AI.

[1110] Step 8:

[1111] The user (applicant) resends the revised application details from the terminal to the server.

[1112] Step 9:

[1113] The server passes the corrected application data to the generation AI again for re-examination. The generation AI then checks whether the previous error has been resolved.

[1114] Step 10:

[1115] The generation AI returns the results after re-examination to the server, and if the problem has been resolved, a report with no errors is provided.

[1116] Step 11:

[1117] The server notifies the user (approver / decisor) of the final error report, indicating whether the error has been resolved or whether a new error has occurred.

[1118] Step 12:

[1119] The user (approver / decisor) checks the application content based on the final error report and decides whether to approve or reject it.

[1120] Step 13:

[1121] Users (approvers and decision makers) enter their approval or rejection feedback into the system, which is important for future learning.

[1122] Step 14:

[1123] The server collects feedback and provides it to the generative AI as data for retraining, which improves accuracy in future iterations.

[1124] The above are the specific processing steps in the system of the present invention.

[1125] Example 1

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

[1127] In today's business environment, the time and effort required for the approval and rejection process for application content is a major challenge. In particular, frequent typos and incomplete descriptions require repeated corrections and resubmissions, placing a heavy burden on approvers and decision makers. Furthermore, technology that learns from past application data to improve the accuracy of review has not yet been fully established, preventing an efficient process. To address these challenges, a system is needed that efficiently reviews application content, notifies users, and provides guidance on how to make corrections.

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

[1129] In this invention, the server includes means for transmitting application content from a terminal to the server, means for the generation AI to learn from past data and scrutinize the application content, means for visualizing error points based on the generation AI's scrutiny results, means for notifying the user of the error points and correction details, means for collecting user feedback and having the generation AI re-learn, means for sending the application content to the server again and having the generation AI re-scrutinize it if the application content is corrected, and means for notifying the user (approver / decisor) of the re-scrutiny results and prompting them to make a final decision. This makes it possible to streamline the application content scrutiny and correction process and significantly reduce the burden on approvers and decision makers.

[1130] "Application content" refers to the data that a user inputs and submits via a terminal to request approval or authorization.

[1131] The "server" is a computer system that sends and receives application details, provides data to the generation AI, and visualizes and notifies error points.

[1132] "Generative AI" is an algorithm or model that learns patterns such as typos and incomplete descriptions based on past application data and then scrutinizes the application content.

[1133] "Error point" is a term that refers to the points where the generation AI detects problems such as typos or insufficient information after carefully examining the application content.

[1134] "User" refers to the applicant who inputs and submits the application details, and the approver / decisor who ultimately approves or rejects the application.

[1135] "Feedback" refers to the evaluations and comments regarding the application collected from users, as well as the results of approval or rejection.

[1136] "Relearning" is the process by which generative AI updates its model based on newly collected feedback data to improve its accuracy.

[1137] "Scrutiny" is a process in which the generation AI analyzes the application content in detail and detects errors such as typos and missing information.

[1138] "Notification" is a means of information transmission by the server to inform the user of the error point and the correction content.

[1139] "Re-examination" is a process in which the generation AI re-analyzes in detail the application content corrected by the user to confirm whether any errors detected previously have been resolved.

[1140] This invention is a system that aims to improve the efficiency of approving or rejecting application content, and mainly utilizes a server, terminals, and a generative AI model. This system uses past application data for the generative AI to learn and examine, reducing the burden on users.

[1141] Hardware and software used

[1142] This system uses the following hardware and software:

[1143] Server: A server machine for high-performance data processing. For example, we will use an AWS EC2 instance.

[1144] Device: A PC or mobile device used by applicants and approvers, using a web browser (such as Google Chrome or Mozilla Firefox).

[1145] Generative AI model: An AI model that learns from past data and scrutinizes application content. It uses TensorFlow and PyTorch.

[1146] Data processing and calculation

[1147] The operation of this system is as follows.

[1148] First, the server collects data such as past application details, approval / denial history, and comments, and provides it to the generation AI. The generation AI then learns from this collected data and creates a model that can identify patterns such as typos and incomplete descriptions.

[1149] Next, the user (applicant) enters the necessary information into the application form on their device and submits it. The device then sends this application data to the server, which then passes it on to the generation AI. The generation AI then carefully examines the application content and detects errors such as typos and missing information.

[1150] Based on the results of the generative AI's inspection, the server visualizes the error points and notifies the user of corrections and points to note. By receiving this notification, users (applicants and approvers) can be sure to understand which parts need to be corrected.

[1151] The user (applicant) then corrects any corrections and submits the data again. The server passes the corrected application data back to the generation AI, which then re-examines it. Once the server confirms that there are no problems, it sends a notification to the user (approver / decisor) for final confirmation.

[1152] Finally, the server collects feedback data and retrains the generative AI to improve accuracy in future iterations. By continuing this feedback process, the system is always adapting to the latest evaluation criteria, enabling more accurate scrutiny.

[1153] Specific examples

[1154] For example, to explain the process of applying for a business trip as a specific example, the user (applicant) enters details such as the purpose of the business trip, schedule, and expenses on a terminal and submits them. The application data is sent to the server, and the generation AI detects errors such as "a typographical error in the expense item or an incomplete accommodation address." The server sorts out the error points and notifies the users (applicant and approver). The user resubmits the corrected content, and the generation AI re-examines it. After confirming that the problem has been resolved, the user (approver / decisor) makes a final check and approves or rejects the application. The server collects feedback and allows the generation AI to re-learn.

[1155] Prompt Sentence Examples

[1156] "What should I pay attention to when filling out a business trip application?"

[1157] "I want to learn about common mistakes made in past applications."

[1158] Please provide a detailed explanation as to why your application was rejected.

[1159] In this way, we aim to streamline the approval process for business trip applications and significantly reduce the burden on approvers and decision makers.

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

[1161] Step 1:

[1162] The server collects data such as past application details, approval / rejection history, and comments.

[1163] Specific operation: The server connects to the business management system database and extracts travel request data from the past year using an SQL query.

[1164] Input: Historical data from business management systems

[1165] Output: Past application data extracted from the database

[1166] Step 2:

[1167] The server provides the collected data to the generation AI.

[1168] Specific operation: The server converts the extracted data into JSON format and sends it to the generative AI's learning module using an HTTP request.

[1169] Input: Extracted past application data

[1170] Output: Training data sent to the generation AI

[1171] Step 3:

[1172] The generative AI learns patterns such as typos and incomplete descriptions based on the data provided.

[1173] What it does: Generative AI uses the data you send it to identify patterns of typos, omissions, and imperfections and trains a neural network model.

[1174] Input: Past application data including typos and incomplete descriptions

[1175] Output: A trained generative AI model

[1176] Step 4:

[1177] The user (applicant) enters a new application into the form from the terminal and submits it.

[1178] Specific operation: The user fills in the necessary information in the travel request form on the browser and clicks the submit button.

[1179] Input: Application information entered by the user into the form

[1180] Output: Application data sent from the terminal

[1181] Step 5:

[1182] The terminal transmits the input application details to the server.

[1183] Specific operation: The terminal converts the input content into XML format and sends it to the server using SSL.

[1184] Input: Application data from the form

[1185] Output: Request data sent to the server

[1186] Step 6:

[1187] The server receives the application data and passes it to the generation AI.

[1188] Specific operation: The server sends the received application data to the generation AI's inspection module.

[1189] Input: Application data sent from the terminal

[1190] Output: Application data sent to the generation AI

[1191] Step 7:

[1192] The generation AI scrutinizes the application content and detects errors such as typos and missing information.

[1193] Specific operation: The generation AI analyzes the application data and detects errors such as "a typo in the expense item" or "an incomplete address for the accommodation."

[1194] Input: Application data

[1195] Output: Error report

[1196] Step 8:

[1197] The server identifies the areas to be corrected based on the error report from the generated AI and visualizes the error points.

[1198] Specific operation: The server analyzes the error report from the generated AI and highlights the error point in red on the web interface.

[1199] Input: Error report from the generation AI

[1200] Output: Visualized error points

[1201] Step 9:

[1202] The server notifies the users (applicant and approver) of any corrections or points to note.

[1203] Specific operation: The server uses the email notification system to send detailed emails including the error point to the applicant and approver.

[1204] Input: Visualized error points

[1205] Output: Notification email showing corrections and points to note

[1206] Step 10:

[1207] The user (applicant) corrects the application details on the terminal and resubmits it.

[1208] Specific actions: The user checks the error email, corrects the indicated items on the form, and clicks the resubmit button.

[1209] Input: Corrected application data

[1210] Output: Resubmitted application data

[1211] Step 11:

[1212] The terminal sends the corrected application details to the server again.

[1213] Specific operation: The terminal re-enters the data and sends it to the server.

[1214] Input: Corrected application data

[1215] Output: Request data resubmitted to the server

[1216] Step 12:

[1217] The server passes the resubmitted application data to the generation AI and conducts a re-examination.

[1218] Specific operation: The server updates the corrected application data and transfers it again to the generation AI's inspection module.

[1219] Input: Resubmitted application data

[1220] Output: Data resubmitted to the generating AI

[1221] Step 13:

[1222] The generating AI will re-examine it to make sure there are no problems.

[1223] Specific behavior: The generation AI analyzes the data again and generates a final error report.

[1224] Input: Resubmitted application data

[1225] Output: Error report of re-examination results

[1226] Step 14:

[1227] The user (approver / decisor) checks the final error report to confirm that the corrections have been completed and approves or rejects the application.

[1228] Specific operation: The approver checks the error report and clicks the approve or reject button on the system.

[1229] Input: Error report of re-examination results

[1230] Output: Approval or rejection decision

[1231] Step 15:

[1232] The server collects feedback data and retrains the generating AI to improve accuracy in future generations.

[1233] Specific operation: The server records the approval / denial results in a database and periodically reflects them in the learning module of the generation AI.

[1234] Input: Approval / Rejection result feedback

[1235] Output: Retrained generative AI model

[1236] (Application example 1)

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

[1238] At logistics centers, when workers replenish inventory or submit various applications, typographical errors or insufficient information in the application content can delay the approval process and reduce work efficiency. Another problem is the burden placed on approvers and decision makers when processing a huge number of applications. To solve these issues, a system is needed that streamlines the review and revision of application content and speeds up the approval process.

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

[1240] In this invention, the server includes means for transmitting application content from an information processing device to a database server, means for a generation AI to learn past data and analyze the application content, means for visualizing error points based on the analysis results of the generation AI, means for notifying an operator of the error points and correction details, means for collecting operator feedback and having the generation AI re-learn, means for an operator to input and correct the application content by voice input or gesture using smart glasses, and means for approving or rejecting the application content via the smart glasses. This makes it possible to quickly detect and correct errors in the application content and streamline the approval process.

[1241] An "information processing device" is a device for data entry, calculation, and information processing.

[1242] A "database server" is a server that centrally stores data and allows multiple users to access it via a network.

[1243] "Generative AI" is a type of artificial intelligence model that can learn from large amounts of data and apply it to new data.

[1244] "Visualization" is the process of making data and information easier to understand by displaying them in a visual format such as a graph or chart.

[1245] "Operator" means a person or device whose role is to operate and manage a machine or system.

[1246] "Smart glasses" are glasses-type devices equipped with displays and sensors that provide functions such as augmented reality and voice input.

[1247] "Voice input" is a technology or method for recognizing a person's voice and converting that speech into text or commands.

[1248] "Gestures" refer to giving instructions or performing operations using hand or body movements.

[1249] "Application" means the details of a formal request or proposal submitted for a specific purpose.

[1250] "Analysis" is the process of breaking down data or information to understand its structure and meaning.

[1251] An "approval process" is a series of procedures that review submitted applications and requests and determine whether to approve them.

[1252] "Feedback" is information about evaluations and reactions to a system or process, which can lead to improvements or adjustments.

[1253] "Retraining" means that generative AI uses new data and feedback to train the model again in order to improve its accuracy and performance.

[1254] This invention is a system for streamlining application processes at logistics centers, and in particular supports the review and approval of application contents for inventory replenishment, etc. The system's main components are an information processing device, a database server, a generation AI, and smart glasses.

[1255] System configuration and operation

[1256] 1. Hardware and Software Used

[1257] Information processing devices: smart glasses (e.g., Google Glass Enterprise Edition 2)

[1258] Database server: High-performance computing server, AWS (Amazon Web Services) infrastructure

[1259] Generated AI: OpenAI GPT-4 API

[1260] Text analysis library: SpaCy

[1261] 2. Data collection and learning

[1262] The server stores data such as past inventory requests, approval / denial history, and comments in an AWS RDS database. This data is provided to OpenAI GPT-4, which learns patterns of typos and incomplete descriptions. This improves the generative AI's ability to efficiently review requests.

[1263] 3. Acceptance and review of application details

[1264] Using smart glasses, workers input new requests (e.g., "I would like to request a replenishment of stock for Type III materials on the next shelf X. The current stock quantity is 10.") into a form using voice input or gestures, and then send the request to the server via the smart glasses. The server then passes the request details to the generation AI via AWS's closed API, and the AI ​​detects errors such as typos and missing information.

[1265] 4. Warnings and Notifications

[1266] The server receives the error report from the AI ​​generator and visualizes the error points based on the report. The visualized error points and points of caution are then notified to the worker via the smart glasses display.

[1267] 5. Corrections and resubmissions

[1268] Workers can use voice input or gestures through the smart glasses to amend the application details, which are then sent back to the server and passed to the AI ​​for further review.

[1269] 6. Re-examination and final confirmation

[1270] The server then uses the AI ​​to analyze the resubmitted application data and check whether the problems have been resolved. If all errors have been corrected, the server notifies the worker via the smart glasses.

[1271] 7. Decision on Approval or Rejection

[1272] The logistics center manager uses the smart glasses to approve or reject the application based on the final error report, thereby completing the application process.

[1273] 8. Feedback and Retraining

[1274] The server collects feedback data on approvals and denials and retrains the generating AI, improving accuracy from the next time onwards.

[1275] Specific examples

[1276] For example, consider a worker speaking the following prompt into smart glasses:

[1277] "I would like to request a replenishment of the next shelf, X, of Type III materials. The current stock quantity is 10."

[1278] The generative AI converts speech to text and analyzes the application to detect error points such as:

[1279] "There is a typo in your inventory replenishment request. Please check again."

[1280] Workers can make corrections and resubmit through the smart glasses, streamlining the application process.

[1281] Example prompt sentence:

[1282] Stock replenishment request:

[1283] Shelf: X

[1284] Product name: III type material

[1285] Currently in stock: 10

[1286] Is there a typo or incompleteness in the above content? Please provide detailed feedback.

[1287] As described above, the present invention is a practical system that significantly improves work efficiency by combining generative AI and smart glasses.

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

[1289] Step 1:

[1290] The server collects and stores data such as past inventory requests, approval / denial history, and comments in an AWS RDS database. This prepares a dataset for the generative AI to learn from. The input is past inventory request data, and the output is the prepared dataset.

[1291] Step 2:

[1292] The server provides the collected dataset to the generative AI (OpenAI GPT-4 API). The generative AI uses this to learn patterns of typos and incomplete descriptions. The input is past inventory request data, and the output is the trained generative AI model. Specifically, the dataset is sent in JSON format to the generative AI API, and the model is trained.

[1293] Step 3:

[1294] The user (worker) uses the smart glasses to input new application details using voice input or gestures. The input is the application details as voice, and the output is the application details converted to text. The smart glasses' microphone and voice recognition software are used to convert the voice to text.

[1295] Step 4:

[1296] The terminal (smart glasses) sends the textual application details to a database server. The input is the textual application details, and the output is the application data stored on the server.

[1297] Step 5:

[1298] The server passes the received application data to the generation AI for scrutiny. The generation AI analyzes the application content and detects errors such as typos and insufficient information. The input is the text version of the application content, and the output is an error report. Specifically, the application data is sent to the generation AI API and the analysis results are obtained.

[1299] Step 6:

[1300] The server visualizes the error points based on the error report from the generation AI. The input is the error report, and the output is the visualized error points. Specifically, it generates text highlighting the error points and sends it to the smart glasses.

[1301] Step 7:

[1302] The user (worker) checks the error points through the smart glasses and corrects the application details using voice input or gestures. The input is the visualized error points and voice input, and the output is the corrected application details.

[1303] Step 8:

[1304] The terminal (smart glasses) sends the corrected application details back to the database server. The input is the corrected application details, and the output is the corrected application data stored on the server.

[1305] Step 9:

[1306] The server passes the resubmitted application data to the generation AI for re-examination. The generation AI analyzes the application again and checks whether the problem has been resolved. The input is the corrected application content, and the output is the final error report.

[1307] Step 10:

[1308] The server confirms that the correction is complete based on the final error report and notifies the worker of this via the smart glasses. The input is the final error report, and the output is the approval notification.

[1309] Step 11:

[1310] The user (logistics center manager) uses the smart glasses to perform the final approval or rejection of the application. The input is the approval notification, and the output is the approval or rejection decision.

[1311] Step 12:

[1312] The server collects feedback data on approvals and denials and retrains the generative AI. The input is the feedback data, and the output is an even more accurate generative AI model.

[1313] This processing flow makes it possible to quickly detect and correct errors in application content and streamline the approval process.

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

[1315] This invention is a system that utilizes generative AI to approve or reject application content, and also combines it with an emotion engine that recognizes user emotions, with the aim of reducing the burden on approvers and decision makers. This section explains the specific components and processing flow of this system.

[1316] Program processing

[1317] Data collection and learning

[1318] The server collects data such as past application details, approval / rejection history, and comments, and provides it to the generation AI.

[1319] Based on this data, the generative AI learns patterns such as typos and incomplete descriptions.

[1320] Acceptance and review of application details

[1321] The user (applicant) enters a new application into the form from the terminal and submits it.

[1322] The terminal transmits the input application details to the server.

[1323] The server receives the application data and passes it to the generation AI.

[1324] The generation AI scrutinizes the application content and detects errors such as typos and missing information.

[1325] Alerts and Notifications

[1326] The server identifies the areas to be corrected based on the error report from the generation AI and visualizes the error points.

[1327] The server notifies the users (applicant and approver) of any corrections or points to note.

[1328] Emotion data collection and analysis

[1329] The emotion engine collects emotional data (e.g., facial expressions, tone of voice, input speed, etc.) when users (applicants and approvers) operate the system.

[1330] The server provides the emotion data collected from the emotion engine to the generation AI for analysis.

[1331] Correct and resubmit

[1332] The user (applicant) checks the error report and corrects the application content. The corrections include the errors identified by the generation AI.

[1333] The terminal sends the corrected application details to the server again.

[1334] Re-examination and final confirmation

[1335] The server passes the corrected application data to the generation AI again for re-examination. The generation AI then checks whether the previous error has been resolved.

[1336] The generation AI returns the results after re-examination to the server, and if the problem has been resolved, a report with no errors is provided.

[1337] Approval or rejection decision

[1338] The user (approver / decisor) checks the application contents based on the final error report and decides whether to approve or reject it.

[1339] The emotion engine recognizes the emotions that approvers and decision makers feel when making decisions and adjusts the form of feedback as needed.

[1340] Feedback and Retraining

[1341] The server collects feedback data and provides it to the generation AI as data for re-learning, which improves accuracy in future iterations.

[1342] The generative AI also learns from emotional data to optimize future notification processes and feedback methods.

[1343] Specific examples

[1344] For example, the approval process for a new project proposal may involve the following steps: Let us consider an example in which a user inputs and submits a project proposal from a terminal.

[1345] The user (applicant) fills out the project proposal form and submits it.

[1346] The terminal transmits the input proposal to the server.

[1347] The server passes the proposal data to the generation AI, which then scrutinizes the content, detecting typos and missing data.

[1348] The emotion engine recognizes the user's emotions and detects, for example, if the user is in a hurry or stressed.

[1349] The server visualizes the error point and notifies the user (applicant and approver).

[1350] The user (submitter) makes corrections and resubmits. The emotion engine also evaluates the user's state at the time of resubmission.

[1351] The generating AI will re-examine the data to ensure that the problem has been resolved.

[1352] The user (approver / decisor) makes a final check and approves or rejects the proposal. The emotion engine recognizes the emotion at the time of decision and adjusts the feedback format accordingly.

[1353] The server collects feedback and retrains the generative AI, optimizing the process for future iterations.

[1354] In this way, the present invention not only improves the efficiency of the application process, but also enables flexible responses according to the emotional state of the user, thereby significantly reducing the burden on approvers and decision makers.

[1355] The processing flow will be explained below.

[1356] Step 1:

[1357] The user (applicant) enters a new application into the form from a terminal. The application contents include necessary information (e.g., name, purpose, schedule, expenses, etc.).

[1358] Step 2:

[1359] The terminal sends the input application content and emotional data (e.g., facial expressions, tone of voice, input speed, etc.) during the user's operation to the server. The emotional data is collected by the emotion engine.

[1360] Step 3:

[1361] The server passes the received application data and emotion data to the generation AI, which then begins the process of examining the application content and analyzing the emotion data simultaneously.

[1362] Step 4:

[1363] The generative AI then scrutinizes the application, detecting errors such as typos, missing required fields, and inconsistent information, and also analyzes emotional data to assess the user's state.

[1364] Step 5:

[1365] The server receives the error report and sentiment analysis results from the AI ​​generation, identifies which part of the application content has a problem, and visualizes the error point. The sentiment analysis results are also included in the report.

[1366] Step 6:

[1367] The server notifies users (applicants and approvers) of the error points and corrections. The notification method is adjusted according to the user's emotional state (e.g., if the user is feeling stressed, the notification will be in gentle language).

[1368] Step 7:

[1369] The user (applicant) checks the error report and emotional advice and corrects the application. The corrections include the errors identified by the generation AI.

[1370] Step 8:

[1371] The user (applicant) resends the revised application details from the terminal to the server. At the same time, the emotion engine collects the user's emotion data again at the time of resending.

[1372] Step 9:

[1373] The server passes the corrected application data and emotion data to the generation AI again for re-examination. The generation AI then checks whether the previous error has been resolved.

[1374] Step 10:

[1375] The generative AI then returns the results to the server after further review. If the problem has been resolved, it will provide an error-free report. At the same time, it also analyzes emotional data to evaluate the user's state.

[1376] Step 11:

[1377] The server notifies the user (approver / decisor) of the final error report and the result of the sentiment analysis. The content of the notification is adjusted based on the user's emotional state.

[1378] Step 12:

[1379] The user (approver / decisor) checks the application content based on the final error report and decides whether to approve or reject it. The emotion engine recognizes the emotions of the approver / decisor when making the decision and adjusts the feedback format as necessary.

[1380] Step 13:

[1381] Users (approvers and decision makers) enter their approval or rejection feedback into the system, which is important for future learning.

[1382] Step 14:

[1383] The server collects feedback and provides it to the generative AI as retraining data, which includes emotional data to optimize future processing.

[1384] The above are the specific processing steps in the system of the present invention. Through this flow, it is possible to streamline the application process while taking into account the emotional state of the user, and significantly reduce the burden on approvers and decision makers.

[1385] Example 2

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

[1387] In the conventional application process, detecting and correcting typos and missing information requires a great deal of time and effort. It also places a heavy psychological burden on approvers and decision makers when they review application documents. Furthermore, while flexible responses based on user emotions are required, this is not being fully implemented. As a result, the entire application process is inefficient, resulting in a poor user experience.

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

[1389] In this invention, the server includes means for transmitting application content from the terminal to the server, means for the server to collect past application data and provide it to the generation AI, means for the generation AI to learn about typos and incomplete descriptions based on the past data and scrutinize the application content, means for visualizing error points based on the generation AI's scrutiny results, means for notifying the user of the error points and corrections, means for the emotion engine to collect user emotion data and provide it to the generation AI, means for re-sending application content corrected by the user to the server and re-scrutinizing it, and means for collecting user feedback and having the generation AI re-learn. This makes it possible to quickly and accurately detect typos and insufficient information and provide flexible feedback according to the user's psychological state.

[1390] 1. "Submission" means any document or information submitted by a User and sent to the Server for a specific purpose, such as proposing a new project or applying for rights.

[1391] 2. "Device" refers to the electronic device used by the user to input and submit application details, including personal computers, smartphones, tablets, etc.

[1392] 3. "Server" refers to the central processing unit that receives the application details sent from the terminal and processes and analyzes the data in cooperation with the generation AI and emotion engine.

[1393] 4. "Generative AI" refers to automated artificial intelligence models that learn from past data and scrutinize applications for typos and incomplete descriptions. For example, they use natural language processing technology to analyze documents.

[1394] 5. "Error points" are typos or missing information detected by the generation AI when examining the application content, and are visualized to prompt the user to make corrections.

[1395] 6. "Emotion engine" refers to technology that collects emotional data from a user's facial expressions, tone of voice, input speed, etc., and recognizes the user's psychological state.

[1396] 7. "Feedback" refers to response information that notifies the user of the results of the generative AI's inspection and information on error points, allowing the user to make corrections based on that information.

[1397] 8. "Retraining" is the process by which the system retrains the generative AI based on newly collected data and user feedback to improve accuracy and efficiency in future generations.

[1398] MODE FOR CARRYING OUT THE INVENTION

[1399] This invention is a system that realizes efficient application processes and flexible responses according to the user's emotional state. This system consists of a terminal, a server, a generation AI, and an emotion engine. The specific functions of each component and their execution procedures are explained below.

[1400] Hardware and software used

[1401] Terminal: Electronic device used by the user to input and submit application details. Examples include personal computers, smartphones, and tablets.

[1402] Server: A central processing unit that receives the application details and processes and analyzes the data in cooperation with the generative AI and emotion engine.

[1403] Generative AI: An automated artificial intelligence model that learns from historical data to refine applications, using natural language processing techniques such as GPT-4.

[1404] Emotion engine: Dedicated software and hardware for analyzing a user's facial expressions, tone of voice, and typing speed to collect emotional data.

[1405] Specific operation explanation

[1406] 1. Acceptance of application details

[1407] The user opens an application form on their device and enters the details of the application, such as a new project proposal or rights application. Once the input is complete, they press the send button to send the data to the server. At this time, the device sends the data securely using the HTTPS protocol.

[1408] 2. Receipt and provision of data

[1409] The server receives the application details sent from the device. At the same time, the server accesses the company's database to collect past application details and approval / denial history, and provides this information to the generation AI. This allows the generation AI to learn from past patterns and improve the accuracy of detecting typos and missing information.

[1410] 3. Review of application details

[1411] The generation AI analyzes the received application content and detects typos and missing information. For example, if there are any typos, it will identify them and also present any required information that is missing from the application content.

[1412] 4. Visualization and notification of error points

[1413] The server visualizes the error points in the application based on the error report returned by the generation AI. Specifically, it highlights the error points in red and notifies the user with instructions to correct them. This notification is sent via email or within the system.

[1414] 5. Emotional Data Collection and Analysis

[1415] The emotion engine collects facial expressions, tone of voice, and input speed in real time when the user edits the application. This emotional data is sent to the server and provided to the generation AI. Based on this data, the generation AI analyzes the user's psychological state, such as whether they are feeling stressed.

[1416] 6. Re-examination and final confirmation

[1417] After the user has completed the corrections, they send the application details back to the server. The server then provides the data to the generation AI again and re-examines it. If the errors have been resolved, a report of the correct status is returned, and the approver makes a final confirmation.

[1418] 7. Feedback and Retraining

[1419] The approver reviews the final error report and makes a decision to approve or reject it. At the same time, the emotion engine analyzes the approver's emotions and adjusts the feedback format as necessary. The server collects the feedback data and retrains the generation AI to further improve accuracy in future iterations.

[1420] Examples of specific examples and prompts

[1421] For example, the approval process for a new project proposal may involve the following steps: Let us consider an example in which a user inputs and submits a project proposal from a terminal.

[1422] 1. Review the project proposal

[1423] "You have entered a new project proposal. Please check for typos and missing information."

[1424] 2. Generate an error report

[1425] "Please create an error report for this project proposal and point out any corrections that need to be made."

[1426] 3. Emotion Data Analysis

[1427] "Analyze whether the user is feeling stressed or not from facial expression data."

[1428] This allows the system to streamline the application process and respond flexibly to the user's emotional state.

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

[1430] Program processing flow

[1431] Step 1:

[1432] Input: A user opens an application form on their device and enters details of an application, such as a new project proposal or rights application.

[1433] Specific operation: The user enters the required information into the form on the terminal and presses the submit button.

[1434] Output: Input data is sent from the device to the server.

[1435] Step 2:

[1436] Input: Application details sent from the terminal

[1437] Specific operation: The server receives data from the device and saves the application details. At the same time, it accesses the company's database to collect past application data and approval / denial history, and provides this information to the generation AI.

[1438] Output: Saved application data and learning data used by the generation AI

[1439] Step 3:

[1440] Input: Past data and new application details provided by the server

[1441] How it works: The generation AI uses natural language processing technology to learn patterns of typos and incomplete descriptions based on past data and then scrutinize the content of new applications.

[1442] Output: Results of review of new application (error report)

[1443] Step 4:

[1444] Input: The inspection result (error report) returned by the generation AI

[1445] Specific operation: The server receives the error report from the generation AI and visualizes the error points. Specifically, it highlights typos and missing information in red and generates correction instructions.

[1446] Output: A visualized error report

[1447] Step 5:

[1448] Input: A visualized error report

[1449] What happens: The server will send a notification to the user containing the error and instructions on how to fix it. This notification can be done via email or an in-system notification.

[1450] Output: Notification of fix to user

[1451] Step 6:

[1452] Input: Facial expressions, tone of voice, typing speed, etc. when users operate the system

[1453] Specific operation: The emotion engine collects the user's emotion data and sends it to the server. The emotion engine collects data using the camera and microphone.

[1454] Output: Emotion data

[1455] Step 7:

[1456] Input: Emotion data sent from the emotion engine

[1457] Specific operation: The server provides emotional data to the generation AI via an analysis API. The generation AI analyzes this emotional data and determines the user's psychological state.

[1458] Output: Psychological state as a result of analysis

[1459] Step 8:

[1460] Input: Application details for which corrections have been notified

[1461] Specific operation: The user corrects the application details based on the error report and presses the submit button again, which causes the corrected data to be resent to the server.

[1462] Output: Corrected application data

[1463] Step 9:

[1464] Input: Corrected application data

[1465] Specific operation: The server provides the correction data to the generation AI again and performs a re-examination. The generation AI checks whether the previous error has been resolved.

[1466] Output: Re-examination result (determining whether the issue has been resolved)

[1467] Step 10:

[1468] Input: Re-examination results

[1469] Specific operation: The server provides the re-examination results to the approver, who makes a final decision based on the error report and the re-examination results.

[1470] Output: Approval or rejection decision

[1471] Step 11:

[1472] Input: Approver's final decision and feedback

[1473] How it works: The server collects feedback and provides it to the generation AI as retraining data, which allows the generation AI to improve its accuracy in future generations.

[1474] Output: Data for retraining

[1475] (Application example 2)

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

[1477] Conventional application review systems using generative AI provide uniform feedback without considering the user's emotional state, which can lead to increased stress and dissatisfaction. Furthermore, the application of review results is not flexible and does not take into account the user's emotions, which increases the burden on approvers and decision makers. The present invention aims to solve these problems.

[1478] 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 for transmitting application content from a terminal to the server, means for the generation AI to learn past data and scrutinize the application content, means for visualizing error points based on the generation AI's scrutiny results, means for notifying the user of the error points and correction details, means for collecting user emotion data and providing it to the emotion engine, means for the emotion engine to analyze the user emotion data and provide the analysis results to the generation AI, and means for collecting user feedback and having the generation AI re-learn. This enables the generation AI to take the user's emotional state into consideration and provide optimal feedback, while also reducing the burden on approvers and decision makers.

[1479] "Application content" refers to the data and information that the user sends to the server.

[1480] "Terminal" refers to an input device used by a user, and includes PCs, tablets, smartphones, etc.

[1481] A "server" is a central computer system that collects, processes, and stores data.

[1482] "Generative AI" is an artificial intelligence system that learns from past data and scrutinizes application content and detects errors.

[1483] "Error points" refer to problematic areas such as typos, omissions, and deficiencies that the generation AI detects in the application content.

[1484] "Visualization" refers to displaying data or information visually to make it easier for users to understand.

[1485] "Emotion data" refers to information such as the user's facial expression, tone of voice, and input speed, and is data used by the emotion engine for analysis.

[1486] The "emotion engine" is a system that analyzes the user's emotional data and recognizes and evaluates their emotional state.

[1487] "Feedback" refers to information that provides a user with notice or instructions regarding error points and corrections.

[1488] "Retraining" refers to the process by which generative AI retrains itself based on new data and feedback to improve its accuracy.

[1489] The present invention is a system that combines generative AI and an emotion engine to approve or reject application content. The specific components and operating procedures for realizing this system are described below.

[1490] The system configuration consists of a terminal, a server, a generative AI, an emotion engine, and a means of communication to link them together.

[1491] 1. Enter and submit your application details

[1492] The user enters the application details from a device (PC, tablet, smartphone, etc.). After input, the application details are sent from the device to the server. At this stage, the device sends data to the server using a communication method, and the server receives the user-entered data.

[1493] 2. Generative AI Scrutiny

[1494] The server passes the application details to the generation AI, which then scrutinizes the application details based on past data. The generation AI detects errors such as typos and incomplete data. This process uses an AI model and associated natural language processing libraries.

[1495] 3. Visualization and notification of error points

[1496] The error points detected by the generation AI are visualized by the server and notified to the user. The server visually represents the error points in an easy-to-understand format and provides them to the user through a notification system. The server also notifies the user of areas that need to be corrected and points that require attention.

[1497] 4. Emotional Data Collection and Analysis

[1498] While the user is interacting with the application, the emotion engine collects emotion data such as the user's facial expressions, tone of voice, and typing speed. This data is acquired through hardware such as a camera, microphone, and keyboard typing speed sensor. The emotion data is sent to the server and provided to the emotion engine.

[1499] 5. Analysis by Emotion Engine

[1500] The emotion engine analyzes the collected emotion data and recognizes the user's emotional state. The emotion engine's analysis results are provided to the generative AI via the server. This information is used to adjust the format and timing of feedback based on the user's emotional state.

[1501] 6. Feedback and Retraining

[1502] When the user corrects the error points and resubmits, the generation AI will re-examine the application to confirm whether the error has been resolved. The result will also be notified to the user via the server. The server will also collect feedback data and provide it to the generation AI for re-learning, thereby improving accuracy from the next time onwards.

[1503] Example prompt:

[1504] Example prompt for the generating AI:

[1505] "Analyze the quality report to detect if it contains errors based on the following patterns: typos, omissions, missing data. Quality report content: {quality report text}"

[1506] Example prompts for the emotion engine:

[1507] "Analyze emotional data such as your facial expressions, tone of voice, and typing speed to recognize when you're stressed or relaxed. Data value: {emotion data}"

[1508] According to the present invention, by examining the application content and providing feedback while taking into consideration the emotional state of the user, it is possible to reduce the burden on approvers and decision makers and to respond to users in a flexible and optimal manner.

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

[1510] Step 1:

[1511] The user uses the terminal to input the application details. The input data is sent from the terminal to the server by pressing the "Send" button. The input is sent to the server as text data.

[1512] Input: Application details (text data)

[1513] Output: Application details sent to the server

[1514] Specific actions: Enter the required information in the application form and click the submit button.

[1515] Step 2:

[1516] The server passes the request details received from the device to the generation AI, which then sends the request details to the generation AI model via an API for analysis.

[1517] Input: Application details sent to the server

[1518] Output: Application details sent to the generation AI

[1519] Specific operation: The server transfers the application details to the generation AI and sends an analysis request.

[1520] Step 3:

[1521] The generative AI model examines the application content and detects errors such as typos and incomplete data. The generative AI learns from past data and identifies error patterns.

[1522] Input: Application details (text data)

[1523] Output: Error points (list format)

[1524] Specific operation: The generation AI analyzes the application content and generates a list of detected error points.

[1525] Step 4:

[1526] The server receives the error points from the AI ​​generator and visually displays the errors to the user. The error points are notified to the user's device.

[1527] Input: Error points (list format)

[1528] Output: Notify the user of the error point

[1529] Specific operation: The server analyzes the error point and generates a message to notify the user.

[1530] Step 5:

[1531] The user corrects the application details and sends them again from the terminal to the server. The corrected data is also transferred to the server.

[1532] Input: Corrected application details

[1533] Output: Modifications sent to the server

[1534] Specific operation: The user corrects the error points and submits the application again.

[1535] Step 6:

[1536] The server passes the revised application details to the generation AI again for re-examination, and the generation AI checks whether the previous error has been resolved.

[1537] Input: Corrected application details

[1538] Output: Re-examination results (whether there are any errors)

[1539] Specific operation: The server forwards the revised application content to the generation AI and sends a re-examination request.

[1540] Step 7:

[1541] The server collects emotional data during user operations and provides it to the emotion engine, which analyzes data such as facial expressions, tone of voice, and input speed.

[1542] Input: Emotional data (facial expressions, tone of voice, typing speed)

[1543] Output: Emotional state (analysis results)

[1544] Specific operation: The server sends emotion data to the emotion engine and sends an analysis request.

[1545] Step 8:

[1546] The analysis results of the emotion engine are provided to the generation AI via the server, and the format and timing of feedback are adjusted based on the user's emotional state.

[1547] Input: Emotional state (analysis result)

[1548] Output: Regulated Feedback

[1549] How it works: The generative AI receives emotional state data and adjusts the format and timing of feedback.

[1550] Step 9:

[1551] The final inspection results are sent to the server and notified to the user. If the problem has been resolved, the application is approved. The feedback data is also stored as data for retraining the generation AI.

[1552] Input: Final review results, feedback data

[1553] Output: Notification to user, data for retraining

[1554] Specific operation: The server notifies the user of the final inspection results and provides the generation AI with data for re-learning.

[1555] Through these steps, the present invention provides a system that significantly reduces the burden on approvers and decision makers by effectively examining and providing feedback on application content while taking into account the user's emotional state.

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

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

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

[1559] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1573] This invention is a system that utilizes generation AI to approve or reject application content, reducing the burden on approvers and decision makers. The main components of this system are a terminal, a server, and generation AI.

[1574] Program processing

[1575] Data collection and learning

[1576] The server collects data such as past application details, approval / rejection history, and comments, and provides it to the generation AI.

[1577] Based on this data, the generative AI learns patterns such as typos and incomplete descriptions.

[1578] Acceptance and review of application details

[1579] The user (applicant) enters a new application into the form from the terminal and submits it.

[1580] The terminal transmits the input application details to the server.

[1581] The server receives the application data and passes it to the generation AI.

[1582] The generation AI scrutinizes the application content and detects errors such as typos and missing information.

[1583] Alerts and Notifications

[1584] The server identifies the areas to be corrected based on the error report from the generation AI and visualizes the error points.

[1585] The server notifies the users (applicant and approver) of any corrections or points to note.

[1586] Correct and resubmit

[1587] The user (applicant) corrects the application details on the terminal and resubmits it.

[1588] The terminal sends the corrected application details to the server again.

[1589] Re-examination and final confirmation

[1590] The server passes the resubmitted application data to the generation AI and conducts a re-examination.

[1591] The generating AI will re-examine it to make sure there are no problems.

[1592] Approval or rejection decision

[1593] The user (approver / decisor) checks the final error report to confirm that the corrections have been completed and approves or rejects the application.

[1594] Feedback and Retraining

[1595] The server collects feedback data and retrains the generating AI to improve accuracy in future generations.

[1596] Specific examples

[1597] For example, consider the process of applying for a business trip. An example will be explained in which a user inputs details such as the purpose of the business trip, schedule, and expenses from a terminal and submits the information.

[1598] The user (applicant) fills in the business trip application form and submits it.

[1599] The terminal sends the application details to the server.

[1600] The server passes the application data to the generation AI, which then examines the contents.

[1601] The generation AI detects errors such as "a typo in an expense item or an incomplete accommodation address."

[1602] The server sorts out the error points and notifies the users (applicant and approver).

[1603] The user (applicant) resubmits the corrected content.

[1604] The generating AI will re-examine the data to ensure that the problem has been resolved.

[1605] The user (approver / decisor) performs the final check and approves or rejects the application.

[1606] The server collects feedback and retrains the generative AI.

[1607] In this way, we aim to streamline the approval process for business trip applications and significantly reduce the burden on approvers and decision makers.

[1608] The processing flow will be explained below.

[1609] Step 1:

[1610] The user (applicant) enters a new application into the form from a terminal. The application contents include necessary information (e.g., name, purpose, schedule, expenses, etc.).

[1611] Step 2:

[1612] The terminal sends the entered application details to the server, which then receives the application data.

[1613] Step 3:

[1614] The server passes the received application data to the generation AI, which then begins the process of examining the application content.

[1615] Step 4:

[1616] The generation AI then scrutinizes the application, detecting errors such as typos, missing required fields, and inconsistent information.

[1617] Step 5:

[1618] The server receives the error report from the generation AI, identifies which part of the application content is problematic, and visualizes the error point.

[1619] Step 6:

[1620] The server notifies the user (applicant and approver) of the error and the corrections required. This notification is often done via email or dashboard.

[1621] Step 7:

[1622] The user (applicant) checks the error report and corrects the application content. The corrections include the errors identified by the generation AI.

[1623] Step 8:

[1624] The user (applicant) resends the revised application details from the terminal to the server.

[1625] Step 9:

[1626] The server passes the corrected application data to the generation AI again for re-examination. The generation AI then checks whether the previous error has been resolved.

[1627] Step 10:

[1628] The generation AI returns the results after re-examination to the server, and if the problem has been resolved, a report with no errors is provided.

[1629] Step 11:

[1630] The server notifies the user (approver / decisor) of the final error report, indicating whether the error has been resolved or whether a new error has occurred.

[1631] Step 12:

[1632] The user (approver / decisor) checks the application content based on the final error report and decides whether to approve or reject it.

[1633] Step 13:

[1634] Users (approvers and decision makers) enter their approval or rejection feedback into the system, which is important for future learning.

[1635] Step 14:

[1636] The server collects feedback and provides it to the generative AI as data for retraining, which improves accuracy in future iterations.

[1637] The above are the specific processing steps in the system of the present invention.

[1638] Example 1

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

[1640] In today's business environment, the time and effort required for the approval and rejection process for application content is a major challenge. In particular, frequent typos and incomplete descriptions require repeated corrections and resubmissions, placing a heavy burden on approvers and decision makers. Furthermore, technology that learns from past application data to improve the accuracy of review has not yet been fully established, preventing an efficient process. To address these challenges, a system is needed that efficiently reviews application content, notifies users, and provides guidance on how to make corrections.

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

[1642] In this invention, the server includes means for transmitting application content from a terminal to the server, means for the generation AI to learn from past data and scrutinize the application content, means for visualizing error points based on the generation AI's scrutiny results, means for notifying the user of the error points and correction details, means for collecting user feedback and having the generation AI re-learn, means for sending the application content to the server again and having the generation AI re-scrutinize it if the application content is corrected, and means for notifying the user (approver / decisor) of the re-scrutiny results and prompting them to make a final decision. This makes it possible to streamline the application content scrutiny and correction process and significantly reduce the burden on approvers and decision makers.

[1643] "Application content" refers to the data that a user inputs and submits via a terminal to request approval or authorization.

[1644] The "server" is a computer system that sends and receives application details, provides data to the generation AI, and visualizes and notifies error points.

[1645] "Generative AI" is an algorithm or model that learns patterns such as typos and incomplete descriptions based on past application data and then scrutinizes the application content.

[1646] "Error point" is a term that refers to the points where the generation AI detects problems such as typos or insufficient information after carefully examining the application content.

[1647] "User" refers to the applicant who inputs and submits the application details, and the approver / decisor who ultimately approves or rejects the application.

[1648] "Feedback" refers to the evaluations and comments regarding the application collected from users, as well as the results of approval or rejection.

[1649] "Relearning" is the process by which generative AI updates its model based on newly collected feedback data to improve its accuracy.

[1650] "Scrutiny" is a process in which the generation AI analyzes the application content in detail and detects errors such as typos and missing information.

[1651] "Notification" is a means of information transmission by the server to inform the user of the error point and the correction content.

[1652] "Re-examination" is a process in which the generation AI re-analyzes in detail the application content corrected by the user to confirm whether any errors detected previously have been resolved.

[1653] This invention is a system that aims to improve the efficiency of approving or rejecting application content, and mainly utilizes a server, terminals, and a generative AI model. This system uses past application data for the generative AI to learn and examine, reducing the burden on users.

[1654] Hardware and software used

[1655] This system uses the following hardware and software:

[1656] Server: A server machine for high-performance data processing. For example, we will use an AWS EC2 instance.

[1657] Device: A PC or mobile device used by applicants and approvers, using a web browser (such as Google Chrome or Mozilla Firefox).

[1658] Generative AI model: An AI model that learns from past data and scrutinizes application content. It uses TensorFlow and PyTorch.

[1659] Data processing and calculation

[1660] The operation of this system is as follows.

[1661] First, the server collects data such as past application details, approval / denial history, and comments, and provides it to the generation AI. The generation AI then learns from this collected data and creates a model that can identify patterns such as typos and incomplete descriptions.

[1662] Next, the user (applicant) enters the necessary information into the application form on their device and submits it. The device then sends this application data to the server, which then passes it on to the generation AI. The generation AI then carefully examines the application content and detects errors such as typos and missing information.

[1663] Based on the results of the generative AI's inspection, the server visualizes the error points and notifies the user of the areas that need to be corrected and points to note. By receiving this notification, users (applicants and approvers) can be sure to understand which areas need to be corrected.

[1664] The user (applicant) then corrects any corrections and submits the data again. The server passes the corrected application data back to the generation AI, which then re-examines it. Once the server confirms that there are no problems, it sends a notification to the user (approver / decisor) for final confirmation.

[1665] Finally, the server collects feedback data and retrains the generative AI to improve accuracy in future iterations. By continuing this feedback process, the system is always adapting to the latest evaluation criteria, enabling more accurate scrutiny.

[1666] Specific examples

[1667] For example, to explain the process of applying for a business trip as a specific example, the user (applicant) enters details such as the purpose of the business trip, schedule, and expenses on a terminal and submits them. The application data is sent to the server, and the generation AI detects errors such as "a typographical error in the expense item or an incomplete accommodation address." The server sorts out the error points and notifies the users (applicant and approver). The user resubmits the corrected content, and the generation AI re-examines it. After confirming that the problem has been resolved, the user (approver / decisor) makes a final check and approves or rejects the application. The server collects feedback and allows the generation AI to re-learn.

[1668] Prompt Sentence Examples

[1669] "What should I pay attention to when filling out a business trip application?"

[1670] "I want to learn about common mistakes made in past applications."

[1671] Please provide a detailed explanation as to why your application was rejected.

[1672] In this way, we aim to streamline the approval process for business trip applications and significantly reduce the burden on approvers and decision makers.

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

[1674] Step 1:

[1675] The server collects data such as past application details, approval / rejection history, and comments.

[1676] Specific operation: The server connects to the business management system database and extracts travel request data from the past year using an SQL query.

[1677] Input: Historical data from business management systems

[1678] Output: Past application data extracted from the database

[1679] Step 2:

[1680] The server provides the collected data to the generation AI.

[1681] Specific operation: The server converts the extracted data into JSON format and sends it to the generative AI's learning module using an HTTP request.

[1682] Input: Extracted past application data

[1683] Output: Training data sent to the generation AI

[1684] Step 3:

[1685] The generative AI learns patterns such as typos and incomplete descriptions based on the data provided.

[1686] What it does: Generative AI uses the data you send it to identify patterns of typos, omissions, and imperfections and trains a neural network model.

[1687] Input: Past application data including typos and incomplete descriptions

[1688] Output: A trained generative AI model

[1689] Step 4:

[1690] The user (applicant) enters a new application into the form from the terminal and submits it.

[1691] Specific operation: The user fills in the necessary information in the travel request form on the browser and clicks the submit button.

[1692] Input: Application information entered by the user into the form

[1693] Output: Application data sent from the terminal

[1694] Step 5:

[1695] The terminal transmits the input application details to the server.

[1696] Specific operation: The terminal converts the input content into XML format and sends it to the server using SSL.

[1697] Input: Application data from the form

[1698] Output: Request data sent to the server

[1699] Step 6:

[1700] The server receives the application data and passes it to the generation AI.

[1701] Specific operation: The server sends the received application data to the generation AI's inspection module.

[1702] Input: Application data sent from the terminal

[1703] Output: Application data sent to the generation AI

[1704] Step 7:

[1705] The generation AI scrutinizes the application content and detects errors such as typos and missing information.

[1706] Specific operation: The generation AI analyzes the application data and detects errors such as "a typo in the expense item" or "an incomplete address for the accommodation."

[1707] Input: Application data

[1708] Output: Error report

[1709] Step 8:

[1710] The server identifies the areas to be corrected based on the error report from the generated AI and visualizes the error points.

[1711] Specific operation: The server analyzes the error report from the generated AI and highlights the error point in red on the web interface.

[1712] Input: Error report from the generation AI

[1713] Output: Visualized error points

[1714] Step 9:

[1715] The server notifies the users (applicant and approver) of any corrections or points to note.

[1716] Specific operation: The server uses the email notification system to send detailed emails including the error point to the applicant and approver.

[1717] Input: Visualized error points

[1718] Output: Notification email showing corrections and points to note

[1719] Step 10:

[1720] The user (applicant) corrects the application details on the terminal and resubmits it.

[1721] Specific actions: The user checks the error email, corrects the indicated items on the form, and clicks the resubmit button.

[1722] Input: Corrected application data

[1723] Output: Resubmitted application data

[1724] Step 11:

[1725] The terminal sends the corrected application details to the server again.

[1726] Specific operation: The terminal re-enters the data and sends it to the server.

[1727] Input: Corrected application data

[1728] Output: Request data resubmitted to the server

[1729] Step 12:

[1730] The server passes the resubmitted application data to the generation AI and conducts a re-examination.

[1731] Specific operation: The server updates the corrected application data and transfers it again to the generation AI's inspection module.

[1732] Input: Resubmitted application data

[1733] Output: Data resubmitted to the generating AI

[1734] Step 13:

[1735] The generating AI will re-examine it to make sure there are no problems.

[1736] Specific behavior: The generation AI analyzes the data again and generates a final error report.

[1737] Input: Resubmitted application data

[1738] Output: Error report of re-examination results

[1739] Step 14:

[1740] The user (approver / decisor) checks the final error report to confirm that the corrections have been completed and approves or rejects the application.

[1741] Specific operation: The approver checks the error report and clicks the approve or reject button on the system.

[1742] Input: Error report of re-examination results

[1743] Output: Approval or rejection decision

[1744] Step 15:

[1745] The server collects feedback data and retrains the generating AI to improve accuracy in future generations.

[1746] Specific operation: The server records the approval / denial results in a database and periodically reflects them in the learning module of the generation AI.

[1747] Input: Approval / Rejection result feedback

[1748] Output: Retrained generative AI model

[1749] (Application example 1)

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

[1751] At logistics centers, when workers replenish inventory or submit various applications, typographical errors or insufficient information in the application content can delay the approval process and reduce work efficiency. Another problem is the burden placed on approvers and decision makers when processing a huge number of applications. To solve these issues, a system is needed that streamlines the review and revision of application content and speeds up the approval process.

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

[1753] In this invention, the server includes means for transmitting application content from an information processing device to a database server, means for a generation AI to learn past data and analyze the application content, means for visualizing error points based on the analysis results of the generation AI, means for notifying an operator of the error points and correction details, means for collecting operator feedback and having the generation AI re-learn, means for an operator to input and correct the application content by voice input or gesture using smart glasses, and means for approving or rejecting the application content via the smart glasses. This makes it possible to quickly detect and correct errors in the application content and streamline the approval process.

[1754] An "information processing device" is a device for data entry, calculation, and information processing.

[1755] A "database server" is a server that centrally stores data and allows multiple users to access it via a network.

[1756] "Generative AI" is a type of artificial intelligence model that can learn from large amounts of data and apply it to new data.

[1757] "Visualization" is the process of making data and information easier to understand by displaying them in a visual format such as a graph or chart.

[1758] "Operator" means a person or device whose role is to operate and manage a machine or system.

[1759] "Smart glasses" are glasses-type devices equipped with displays and sensors that provide functions such as augmented reality and voice input.

[1760] "Voice input" is a technology or method for recognizing a person's voice and converting that speech into text or commands.

[1761] "Gestures" refer to giving instructions or performing operations using hand or body movements.

[1762] "Application" means the details of a formal request or proposal submitted for a specific purpose.

[1763] "Analysis" is the process of breaking down data or information to understand its structure and meaning.

[1764] An "approval process" is a series of procedures that review submitted applications and requests and determine whether to approve them.

[1765] "Feedback" is information about evaluations and reactions to a system or process, which can lead to improvements or adjustments.

[1766] "Retraining" means that generative AI uses new data and feedback to train the model again in order to improve its accuracy and performance.

[1767] This invention is a system for streamlining application processes at logistics centers, and in particular supports the review and approval of application contents for inventory replenishment, etc. The system's main components are an information processing device, a database server, a generation AI, and smart glasses.

[1768] System configuration and operation

[1769] 1. Hardware and Software Used

[1770] Information processing devices: smart glasses (e.g., Google Glass Enterprise Edition 2)

[1771] Database server: High-performance computing server, AWS (Amazon Web Services) infrastructure

[1772] Generated AI: OpenAI GPT-4 API

[1773] Text analysis library: SpaCy

[1774] 2. Data collection and learning

[1775] The server stores data such as past inventory requests, approval / denial history, and comments in an AWS RDS database. This data is provided to OpenAI GPT-4, which learns patterns of typos and incomplete descriptions. This improves the generative AI's ability to efficiently review requests.

[1776] 3. Acceptance and review of application details

[1777] Using smart glasses, workers input new requests (e.g., "I would like to request a replenishment of stock for Type III materials on the next shelf X. The current stock quantity is 10.") into a form using voice input or gestures, and then send the request to the server via the smart glasses. The server then passes the request details to the generation AI via AWS's closed API, and the AI ​​detects errors such as typos and missing information.

[1778] 4. Warnings and Notifications

[1779] The server receives the error report from the AI ​​generator and visualizes the error points based on the report. The visualized error points and points of caution are then notified to the worker via the smart glasses display.

[1780] 5. Corrections and resubmissions

[1781] Workers can use voice input or gestures through the smart glasses to amend the application details, which are then sent back to the server and passed to the AI ​​for further review.

[1782] 6. Re-examination and final confirmation

[1783] The server then uses the AI ​​to analyze the resubmitted application data and check whether the problems have been resolved. If all errors have been corrected, the server notifies the worker via the smart glasses.

[1784] 7. Decision on Approval or Rejection

[1785] The logistics center manager uses the smart glasses to approve or reject the application based on the final error report, thereby completing the application process.

[1786] 8. Feedback and Retraining

[1787] The server collects feedback data on approvals and denials and retrains the generating AI, improving accuracy from the next time onwards.

[1788] Specific examples

[1789] For example, consider a worker speaking the following prompt into smart glasses:

[1790] "I would like to request a replenishment of the next shelf, X, of Type III materials. The current stock quantity is 10."

[1791] The generative AI converts speech to text and analyzes the application to detect error points such as:

[1792] "There is a typo in your inventory replenishment request. Please check again."

[1793] Workers can make corrections and resubmit through the smart glasses, streamlining the application process.

[1794] Example prompt sentence:

[1795] Stock replenishment request:

[1796] Shelf: X

[1797] Product name: III type material

[1798] Currently in stock: 10

[1799] Is there a typo or incompleteness in the above content? Please provide detailed feedback.

[1800] As described above, the present invention is a practical system that significantly improves work efficiency by combining generative AI and smart glasses.

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

[1802] Step 1:

[1803] The server collects and stores data such as past inventory requests, approval / denial history, and comments in an AWS RDS database. This prepares a dataset for the generative AI to learn from. The input is past inventory request data, and the output is the prepared dataset.

[1804] Step 2:

[1805] The server provides the collected dataset to the generative AI (OpenAI GPT-4 API). The generative AI uses this to learn patterns of typos and incomplete descriptions. The input is past inventory request data, and the output is the trained generative AI model. Specifically, the dataset is sent in JSON format to the generative AI API, and the model is trained.

[1806] Step 3:

[1807] The user (worker) uses the smart glasses to input new application details using voice input or gestures. The input is the application details as voice, and the output is the application details converted to text. The smart glasses' microphone and voice recognition software are used to convert the voice to text.

[1808] Step 4:

[1809] The terminal (smart glasses) sends the textual application details to a database server. The input is the textual application details, and the output is the application data stored on the server.

[1810] Step 5:

[1811] The server passes the received application data to the generation AI for scrutiny. The generation AI analyzes the application content and detects errors such as typos and insufficient information. The input is the text version of the application content, and the output is an error report. Specifically, the application data is sent to the generation AI API and the analysis results are obtained.

[1812] Step 6:

[1813] The server visualizes the error points based on the error report from the generation AI. The input is the error report, and the output is the visualized error points. Specifically, it generates text highlighting the error points and sends it to the smart glasses.

[1814] Step 7:

[1815] The user (worker) checks the error points through the smart glasses and corrects the application details using voice input or gestures. The input is the visualized error points and voice input, and the output is the corrected application details.

[1816] Step 8:

[1817] The terminal (smart glasses) sends the corrected application details back to the database server. The input is the corrected application details, and the output is the corrected application data stored on the server.

[1818] Step 9:

[1819] The server passes the resubmitted application data to the generation AI for re-examination. The generation AI analyzes the application again and checks whether the problem has been resolved. The input is the corrected application content, and the output is the final error report.

[1820] Step 10:

[1821] The server confirms that the correction is complete based on the final error report and notifies the worker of this via the smart glasses. The input is the final error report, and the output is the approval notification.

[1822] Step 11:

[1823] The user (logistics center manager) uses the smart glasses to perform the final approval or rejection of the application. The input is the approval notification, and the output is the approval or rejection decision.

[1824] Step 12:

[1825] The server collects feedback data on approvals and denials and retrains the generative AI. The input is the feedback data, and the output is an even more accurate generative AI model.

[1826] This processing flow makes it possible to quickly detect and correct errors in application content and streamline the approval process.

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

[1828] This invention is a system that utilizes generative AI to approve or reject application content, and also combines it with an emotion engine that recognizes user emotions, with the aim of reducing the burden on approvers and decision makers. This section explains the specific components and processing flow of this system.

[1829] Program processing

[1830] Data collection and learning

[1831] The server collects data such as past application details, approval / rejection history, and comments, and provides it to the generation AI.

[1832] Based on this data, the generative AI learns patterns such as typos and incomplete descriptions.

[1833] Acceptance and review of application details

[1834] The user (applicant) enters a new application into the form from the terminal and submits it.

[1835] The terminal transmits the input application details to the server.

[1836] The server receives the application data and passes it to the generation AI.

[1837] The generation AI scrutinizes the application content and detects errors such as typos and missing information.

[1838] Alerts and Notifications

[1839] The server identifies the areas to be corrected based on the error report from the generation AI and visualizes the error points.

[1840] The server notifies the users (applicant and approver) of any corrections or points to note.

[1841] Emotion data collection and analysis

[1842] The emotion engine collects emotional data (e.g., facial expressions, tone of voice, input speed, etc.) when users (applicants and approvers) operate the system.

[1843] The server provides the emotion data collected from the emotion engine to the generation AI for analysis.

[1844] Correct and resubmit

[1845] The user (applicant) checks the error report and corrects the application content. The corrections include the errors identified by the generation AI.

[1846] The terminal sends the corrected application details to the server again.

[1847] Re-examination and final confirmation

[1848] The server passes the corrected application data to the generation AI again for re-examination. The generation AI then checks whether the previous error has been resolved.

[1849] The generation AI returns the results after re-examination to the server, and if the problem has been resolved, a report with no errors is provided.

[1850] Approval or rejection decision

[1851] The user (approver / decisor) checks the application contents based on the final error report and decides whether to approve or reject it.

[1852] The emotion engine recognizes the emotions that approvers and decision makers feel when making decisions and adjusts the form of feedback as needed.

[1853] Feedback and Retraining

[1854] The server collects feedback data and provides it to the generation AI as data for re-learning, which improves accuracy in future iterations.

[1855] The generative AI also learns from emotional data to optimize future notification processes and feedback methods.

[1856] Specific examples

[1857] For example, the approval process for a new project proposal may involve the following steps: Let us consider an example in which a user inputs and submits a project proposal from a terminal.

[1858] The user (applicant) fills out the project proposal form and submits it.

[1859] The terminal transmits the input proposal to the server.

[1860] The server passes the proposal data to the generation AI, which then scrutinizes the content, detecting typos and missing data.

[1861] The emotion engine recognizes the user's emotions and detects, for example, if the user is in a hurry or stressed.

[1862] The server visualizes the error point and notifies the user (applicant and approver).

[1863] The user (submitter) makes corrections and resubmits. The emotion engine also evaluates the user's state at the time of resubmission.

[1864] The generating AI will re-examine the data to ensure that the problem has been resolved.

[1865] The user (approver / decisor) makes a final check and approves or rejects the proposal. The emotion engine recognizes the emotion at the time of decision and adjusts the feedback format accordingly.

[1866] The server collects feedback and retrains the generative AI, optimizing the process for future iterations.

[1867] In this way, the present invention not only improves the efficiency of the application process, but also enables flexible responses according to the emotional state of the user, thereby significantly reducing the burden on approvers and decision makers.

[1868] The processing flow will be explained below.

[1869] Step 1:

[1870] The user (applicant) enters a new application into the form from a terminal. The application contents include necessary information (e.g., name, purpose, schedule, expenses, etc.).

[1871] Step 2:

[1872] The terminal sends the input application content and emotional data (e.g., facial expressions, tone of voice, input speed, etc.) during the user's operation to the server. The emotional data is collected by the emotion engine.

[1873] Step 3:

[1874] The server passes the received application data and emotion data to the generation AI, which then begins the process of examining the application content and analyzing the emotion data simultaneously.

[1875] Step 4:

[1876] The generative AI then scrutinizes the application, detecting errors such as typos, missing required fields, and inconsistent information, and also analyzes emotional data to assess the user's state.

[1877] Step 5:

[1878] The server receives the error report and sentiment analysis results from the AI ​​generation, identifies which part of the application content has a problem, and visualizes the error point. The sentiment analysis results are also included in the report.

[1879] Step 6:

[1880] The server notifies users (applicants and approvers) of the error points and corrections. The notification method is adjusted according to the user's emotional state (e.g., if the user is feeling stressed, the notification will be in gentle language).

[1881] Step 7:

[1882] The user (applicant) checks the error report and emotional advice and corrects the application. The corrections include the errors identified by the generation AI.

[1883] Step 8:

[1884] The user (applicant) resends the revised application details from the terminal to the server. At the same time, the emotion engine collects the user's emotion data again at the time of resending.

[1885] Step 9:

[1886] The server passes the corrected application data and emotion data to the generation AI again for re-examination. The generation AI then checks whether the previous error has been resolved.

[1887] Step 10:

[1888] The generative AI then returns the results to the server after further review. If the problem has been resolved, it will provide an error-free report. At the same time, it also analyzes emotional data to evaluate the user's state.

[1889] Step 11:

[1890] The server notifies the user (approver / decisor) of the final error report and the result of the sentiment analysis. The content of the notification is adjusted based on the user's emotional state.

[1891] Step 12:

[1892] The user (approver / decisor) checks the application content based on the final error report and decides whether to approve or reject it. The emotion engine recognizes the emotions of the approver / decisor when making the decision and adjusts the feedback format as necessary.

[1893] Step 13:

[1894] Users (approvers and decision makers) enter their approval or rejection feedback into the system, which is important for future learning.

[1895] Step 14:

[1896] The server collects feedback and provides it to the generative AI as retraining data, which includes emotional data to optimize future processing.

[1897] The above are the specific processing steps in the system of the present invention. Through this flow, it is possible to streamline the application process while taking into account the emotional state of the user, and significantly reduce the burden on approvers and decision makers.

[1898] Example 2

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

[1900] In the conventional application process, detecting and correcting typos and missing information requires a great deal of time and effort. It also places a heavy psychological burden on approvers and decision makers when they review application documents. Furthermore, while flexible responses based on user emotions are required, this is not being fully implemented. As a result, the entire application process is inefficient, resulting in a poor user experience.

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

[1902] In this invention, the server includes means for transmitting application content from the terminal to the server, means for the server to collect past application data and provide it to the generation AI, means for the generation AI to learn about typos and incomplete descriptions based on the past data and scrutinize the application content, means for visualizing error points based on the generation AI's scrutiny results, means for notifying the user of the error points and corrections, means for the emotion engine to collect user emotion data and provide it to the generation AI, means for re-sending application content corrected by the user to the server and re-scrutinizing it, and means for collecting user feedback and having the generation AI re-learn. This makes it possible to quickly and accurately detect typos and insufficient information and provide flexible feedback according to the user's psychological state.

[1903] 1. "Submission" means any document or information submitted by a User and sent to the Server for a specific purpose, such as proposing a new project or applying for rights.

[1904] 2. "Device" refers to the electronic device used by the user to input and submit application details, including personal computers, smartphones, tablets, etc.

[1905] 3. "Server" refers to the central processing unit that receives the application details sent from the terminal and processes and analyzes the data in cooperation with the generation AI and emotion engine.

[1906] 4. "Generative AI" refers to automated artificial intelligence models that learn from past data and scrutinize applications for typos and incomplete descriptions. For example, they use natural language processing technology to analyze documents.

[1907] 5. "Error points" are typos or missing information detected by the generation AI when examining the application content, and are visualized to prompt the user to make corrections.

[1908] 6. "Emotion engine" refers to technology that collects emotional data from a user's facial expressions, tone of voice, input speed, etc., and recognizes the user's psychological state.

[1909] 7. "Feedback" refers to response information that notifies the user of the results of the generative AI's inspection and information on error points, allowing the user to make corrections based on that information.

[1910] 8. "Retraining" is the process by which the system retrains the generative AI based on newly collected data and user feedback to improve accuracy and efficiency in future generations.

[1911] MODE FOR CARRYING OUT THE INVENTION

[1912] This invention is a system that realizes efficient application processes and flexible responses according to the user's emotional state. This system consists of a terminal, a server, a generation AI, and an emotion engine. The specific functions of each component and their execution procedures are explained below.

[1913] Hardware and software used

[1914] Terminal: Electronic device used by the user to input and submit application details. Examples include personal computers, smartphones, and tablets.

[1915] Server: A central processing unit that receives the application details and processes and analyzes the data in cooperation with the generative AI and emotion engine.

[1916] Generative AI: An automated artificial intelligence model that learns from historical data to refine applications, using natural language processing techniques such as GPT-4.

[1917] Emotion engine: Dedicated software and hardware for analyzing a user's facial expressions, tone of voice, and typing speed to collect emotional data.

[1918] Specific operation explanation

[1919] 1. Acceptance of application details

[1920] The user opens an application form on their device and enters the details of the application, such as a new project proposal or rights application. Once the input is complete, they press the send button to send the data to the server. At this time, the device sends the data securely using the HTTPS protocol.

[1921] 2. Receipt and provision of data

[1922] The server receives the application details sent from the device. At the same time, the server accesses the company's database to collect past application details and approval / denial history, and provides this information to the generation AI. This allows the generation AI to learn from past patterns and improve the accuracy of detecting typos and missing information.

[1923] 3. Review of application details

[1924] The generation AI analyzes the received application content and detects typos and missing information. For example, if there are any typos, it will identify them and also present any required information that is missing from the application content.

[1925] 4. Visualization and notification of error points

[1926] The server visualizes the error points in the application based on the error report returned by the generation AI. Specifically, it highlights the error points in red and notifies the user with instructions to correct them. This notification is sent via email or within the system.

[1927] 5. Emotional Data Collection and Analysis

[1928] The emotion engine collects facial expressions, tone of voice, and input speed in real time when the user edits the application. This emotional data is sent to the server and provided to the generation AI. Based on this data, the generation AI analyzes the user's psychological state, such as whether they are feeling stressed.

[1929] 6. Re-examination and final confirmation

[1930] After the user has completed the corrections, they send the application details back to the server. The server then provides the data to the generation AI again and re-examines it. If the errors have been resolved, a report of the correct status is returned, and the approver makes a final confirmation.

[1931] 7. Feedback and Retraining

[1932] The approver reviews the final error report and makes a decision to approve or reject it. At the same time, the emotion engine analyzes the approver's emotions and adjusts the feedback format as necessary. The server collects the feedback data and retrains the generation AI to further improve accuracy in future iterations.

[1933] Examples of specific examples and prompts

[1934] For example, the approval process for a new project proposal may involve the following steps: Let us consider an example in which a user inputs and submits a project proposal from a terminal.

[1935] 1. Review the project proposal

[1936] "You have entered a new project proposal. Please check for typos and missing information."

[1937] 2. Generate an error report

[1938] "Please create an error report for this project proposal and point out any corrections that need to be made."

[1939] 3. Emotion Data Analysis

[1940] "Analyze whether the user is feeling stressed or not from facial expression data."

[1941] This allows the system to streamline the application process and respond flexibly to the user's emotional state.

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

[1943] Program processing flow

[1944] Step 1:

[1945] Input: A user opens an application form on their device and enters details of an application, such as a new project proposal or rights application.

[1946] Specific operation: The user enters the required information into the form on the terminal and presses the submit button.

[1947] Output: Input data is sent from the device to the server.

[1948] Step 2:

[1949] Input: Application details sent from the terminal

[1950] Specific operation: The server receives data from the device and saves the application details. At the same time, it accesses the company's database to collect past application data and approval / denial history, and provides this information to the generation AI.

[1951] Output: Saved application data and learning data used by the generation AI

[1952] Step 3:

[1953] Input: Past data and new application details provided by the server

[1954] How it works: The generation AI uses natural language processing technology to learn patterns of typos and incomplete descriptions based on past data and then scrutinize the content of new applications.

[1955] Output: Results of review of new application (error report)

[1956] Step 4:

[1957] Input: The inspection result (error report) returned by the generation AI

[1958] Specific operation: The server receives the error report from the generation AI and visualizes the error points. Specifically, it highlights typos and missing information in red and generates correction instructions.

[1959] Output: A visualized error report

[1960] Step 5:

[1961] Input: A visualized error report

[1962] What happens: The server will send a notification to the user containing the error and instructions on how to fix it. This notification can be done via email or an in-system notification.

[1963] Output: Notification of fix to user

[1964] Step 6:

[1965] Input: Facial expressions, tone of voice, typing speed, etc. when users operate the system

[1966] Specific operation: The emotion engine collects the user's emotion data and sends it to the server. The emotion engine collects data using the camera and microphone.

[1967] Output: Emotion data

[1968] Step 7:

[1969] Input: Emotion data sent from the emotion engine

[1970] Specific operation: The server provides emotional data to the generation AI via an analysis API. The generation AI analyzes this emotional data and determines the user's psychological state.

[1971] Output: Psychological state as a result of analysis

[1972] Step 8:

[1973] Input: Application details for which corrections have been notified

[1974] Specific operation: The user corrects the application details based on the error report and presses the submit button again, which causes the corrected data to be resent to the server.

[1975] Output: Corrected application data

[1976] Step 9:

[1977] Input: Corrected application data

[1978] Specific operation: The server provides the correction data to the generation AI again and performs a re-examination. The generation AI checks whether the previous error has been resolved.

[1979] Output: Re-examination result (determining whether the issue has been resolved)

[1980] Step 10:

[1981] Input: Re-examination results

[1982] Specific operation: The server provides the re-examination results to the approver, who makes a final decision based on the error report and the re-examination results.

[1983] Output: Approval or rejection decision

[1984] Step 11:

[1985] Input: Approver's final decision and feedback

[1986] How it works: The server collects feedback and provides it to the generation AI as retraining data, which allows the generation AI to improve its accuracy in future generations.

[1987] Output: Data for retraining

[1988] (Application example 2)

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

[1990] Conventional application review systems using generative AI provide uniform feedback without considering the user's emotional state, which can lead to increased stress and dissatisfaction. Furthermore, the application of review results is not flexible and does not take into account the user's emotions, which increases the burden on approvers and decision makers. The present invention aims to solve these problems.

[1991] 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 for transmitting application content from a terminal to the server, means for the generation AI to learn past data and scrutinize the application content, means for visualizing error points based on the generation AI's scrutiny results, means for notifying the user of the error points and correction details, means for collecting user emotion data and providing it to the emotion engine, means for the emotion engine to analyze the user emotion data and provide the analysis results to the generation AI, and means for collecting user feedback and having the generation AI re-learn. This enables the generation AI to take the user's emotional state into consideration and provide optimal feedback, while also reducing the burden on approvers and decision makers.

[1992] "Application content" refers to the data and information that the user sends to the server.

[1993] "Terminal" refers to an input device used by a user, and includes PCs, tablets, smartphones, etc.

[1994] A "server" is a central computer system that collects, processes, and stores data.

[1995] "Generative AI" is an artificial intelligence system that learns from past data and scrutinizes application content and detects errors.

[1996] "Error points" refer to problematic areas such as typos, omissions, and deficiencies that the generation AI detects in the application content.

[1997] "Visualization" refers to displaying data or information visually to make it easier for users to understand.

[1998] "Emotion data" refers to information such as the user's facial expression, tone of voice, and input speed, and is data used by the emotion engine for analysis.

[1999] The "emotion engine" is a system that analyzes the user's emotional data and recognizes and evaluates their emotional state.

[2000] "Feedback" refers to information that provides a user with notice or instructions regarding error points and corrections.

[2001] "Retraining" refers to the process by which generative AI retrains itself based on new data and feedback to improve its accuracy.

[2002] The present invention is a system that combines generative AI and an emotion engine to approve or reject application content. The specific components and operating procedures for realizing this system are described below.

[2003] The system configuration consists of a terminal, a server, a generative AI, an emotion engine, and a means of communication to link them together.

[2004] 1. Enter and submit your application details

[2005] The user enters the application details from a device (PC, tablet, smartphone, etc.). After input, the application details are sent from the device to the server. At this stage, the device sends data to the server using a communication method, and the server receives the user-entered data.

[2006] 2. Generative AI Scrutiny

[2007] The server passes the application details to the generation AI, which then scrutinizes the application details based on past data. The generation AI detects errors such as typos and incomplete data. This process uses an AI model and associated natural language processing libraries.

[2008] 3. Visualization and notification of error points

[2009] The error points detected by the generation AI are visualized by the server and notified to the user. The server visually represents the error points in an easy-to-understand format and provides them to the user through a notification system. The server also notifies the user of areas that need to be corrected and points that require attention.

[2010] 4. Emotional Data Collection and Analysis

[2011] While the user is interacting with the application, the emotion engine collects emotion data such as the user's facial expressions, tone of voice, and typing speed. This data is acquired through hardware such as a camera, microphone, and keyboard typing speed sensor. The emotion data is sent to the server and provided to the emotion engine.

[2012] 5. Analysis by Emotion Engine

[2013] The emotion engine analyzes the collected emotion data and recognizes the user's emotional state. The emotion engine's analysis results are provided to the generative AI via the server. This information is used to adjust the format and timing of feedback based on the user's emotional state.

[2014] 6. Feedback and Retraining

[2015] When the user corrects the error points and resubmits, the generation AI will re-examine the application to confirm whether the error has been resolved. The result will also be notified to the user via the server. The server will also collect feedback data and provide it to the generation AI for re-learning, thereby improving accuracy from the next time onwards.

[2016] Example prompt:

[2017] Example prompt for the generating AI:

[2018] "Analyze the quality report to detect if it contains errors based on the following patterns: typos, omissions, missing data. Quality report content: {quality report text}"

[2019] Example prompts for the emotion engine:

[2020] "Analyze emotional data such as your facial expressions, tone of voice, and typing speed to recognize when you're stressed or relaxed. Data value: {emotion data}"

[2021] According to the present invention, by examining the application content and providing feedback while taking into consideration the emotional state of the user, it is possible to reduce the burden on approvers and decision makers and to respond to users in a flexible and optimal manner.

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

[2023] Step 1:

[2024] The user uses the terminal to input the application details. The input data is sent from the terminal to the server by pressing the "Send" button. The input is sent to the server as text data.

[2025] Input: Application details (text data)

[2026] Output: Application details sent to the server

[2027] Specific actions: Enter the required information in the application form and click the submit button.

[2028] Step 2:

[2029] The server passes the request details received from the device to the generation AI, which then sends the request details to the generation AI model via an API for analysis.

[2030] Input: Application details sent to the server

[2031] Output: Application details sent to the generation AI

[2032] Specific operation: The server transfers the application details to the generation AI and sends an analysis request.

[2033] Step 3:

[2034] The generative AI model examines the application content and detects errors such as typos and incomplete data. The generative AI learns from past data and identifies error patterns.

[2035] Input: Application details (text data)

[2036] Output: Error points (list format)

[2037] Specific operation: The generation AI analyzes the application content and generates a list of detected error points.

[2038] Step 4:

[2039] The server receives the error points from the AI ​​generator and visually displays the errors to the user. The error points are notified to the user's device.

[2040] Input: Error points (list format)

[2041] Output: Notify the user of the error point

[2042] Specific operation: The server analyzes the error point and generates a message to notify the user.

[2043] Step 5:

[2044] The user corrects the application details and sends them again from the terminal to the server. The corrected data is also transferred to the server.

[2045] Input: Corrected application details

[2046] Output: Modifications sent to the server

[2047] Specific operation: The user corrects the error points and submits the application again.

[2048] Step 6:

[2049] The server passes the revised application details to the generation AI again for re-examination, and the generation AI checks whether the previous error has been resolved.

[2050] Input: Corrected application details

[2051] Output: Re-examination results (whether there are any errors)

[2052] Specific operation: The server forwards the revised application content to the generation AI and sends a re-examination request.

[2053] Step 7:

[2054] The server collects emotional data during user operations and provides it to the emotion engine, which analyzes data such as facial expressions, tone of voice, and input speed.

[2055] Input: Emotional data (facial expressions, tone of voice, typing speed)

[2056] Output: Emotional state (analysis results)

[2057] Specific operation: The server sends emotion data to the emotion engine and sends an analysis request.

[2058] Step 8:

[2059] The analysis results of the emotion engine are provided to the generation AI via the server, and the format and timing of feedback are adjusted based on the user's emotional state.

[2060] Input: Emotional state (analysis result)

[2061] Output: Regulated Feedback

[2062] How it works: The generative AI receives emotional state data and adjusts the format and timing of feedback.

[2063] Step 9:

[2064] The final inspection results are sent to the server and notified to the user. If the problem has been resolved, the application is approved. The feedback data is also stored as data for retraining the generation AI.

[2065] Input: Final review results, feedback data

[2066] Output: Notification to user, data for retraining

[2067] Specific operation: The server notifies the user of the final inspection results and provides the generation AI with data for re-learning.

[2068] Through these steps, the present invention provides a system that significantly reduces the burden on approvers and decision makers by effectively examining and providing feedback on application content while taking into account the user's emotional state.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[2088] 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, in order to avoid confusion and to 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.

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

[2090] The following is further disclosed regarding the above embodiment.

[2091] (Claim 1)

[2092] means for transmitting application details from the terminal to a server;

[2093] The generation AI learns from past data and examines the application content.

[2094] A method for visualizing error points based on the results of the generative AI's inspection,

[2095] A means for notifying the user of the error points and correction contents;

[2096] A means of collecting user feedback and retraining the generative AI,

[2097] A system including:

[2098] (Claim 2)

[2099] The system according to claim 1, further comprising a means for the generation AI to periodically update the learning data before notifying the error point.

[2100] (Claim 3)

[2101] 2. The system according to claim 1, further comprising means for re-examining application details amended by the user.

[2102] "Example 1"

[2103] (Claim 1)

[2104] means for transmitting application details from the terminal to a server;

[2105] The generation AI learns from past data and examines the application content.

[2106] A method for visualizing error points based on the results of the generative AI's inspection,

[2107] A means for notifying the user of the error points and correction contents;

[2108] A means of collecting user feedback and retraining the generative AI,

[2109] If the application details are revised, they will be sent to the server again and re-examined by the generation AI.

[2110] A means to notify the user (approver / decisor) of the re-examination results and prompt the final decision,

[2111] A system including:

[2112] (Claim 2)

[2113] The system according to claim 1, further comprising a means for the generation AI to periodically update the learning data before notifying the error point.

[2114] (Claim 3)

[2115] 2. The system according to claim 1, further comprising means for re-examining application details amended by the user.

[2116] "Application Example 1"

[2117] (Claim 1)

[2118] means for transmitting application details from an information processing device to a database server;

[2119] The generation AI learns from past data and analyzes the application content,

[2120] A method for visualizing error points based on the analysis results of the generative AI,

[2121] A means for notifying an operator of the error point and the correction content;

[2122] A means to collect operator feedback and retrain the generative AI,

[2123] Using smart glasses, operators can input and correct application details using voice input and gestures,

[2124] a means for approving or denying the application via the smart glasses;

[2125] A system including:

[2126] (Claim 2)

[2127] The system according to claim 1, further comprising a means for the generation AI to periodically update the learning data before notifying the error point.

[2128] (Claim 3)

[2129] 2. The system of claim 1, further comprising means for reanalyzing application content modified by an operator.

[2130] "Example 2: Combining Emotion Engines"

[2131] Rewriting of claims

[2132] (Claim 1)

[2133] means for transmitting application details from the terminal to a server;

[2134] The server collects past application data and provides it to the generation AI.

[2135] The generation AI learns from past data about typos and incomplete descriptions and then carefully examines the application content.

[2136] A method for visualizing error points based on the results of the generative AI's inspection,

[2137] A means for notifying the user of the error points and correction contents;

[2138] A means for the emotion engine to collect user emotion data and provide it to the generation AI;

[2139] A means for re-sending the application details corrected by the user to the server and re-examining them;

[2140] A means of collecting user feedback and retraining the generative AI,

[2141] A system including:

[2142] (Claim 2)

[2143] The system according to claim 1, wherein the generation AI is provided with means for periodically updating the learning data.

[2144] (Claim 3)

[2145] 10. The system of claim 1, wherein the server includes means for analyzing data from the emotion engine and for the generative AI to provide feedback according to the user's emotional state.

[2146] "Application example 2 when combining emotion engines"

[2147] (Claim 1)

[2148] means for transmitting application details from the terminal to a server;

[2149] The generation AI learns from past data and examines the application content.

[2150] A method for visualizing error points based on the resul...

Claims

1. means for transmitting application details from the terminal to a server; The generation AI learns from past data and examines the application content. A method for visualizing error points based on the results of the generative AI's inspection, A means for notifying the user of the error points and correction contents; A means of collecting user feedback and retraining the generative AI, A system including:

2. The system according to claim 1, further comprising a means for the generation AI to periodically update the learning data before notifying the error point.

3. 2. The system according to claim 1, further comprising means for re-examining application content that has been modified by the user.

Images