system

Abstract

Provide a system. [Solution] a means for a user to input a request for material creation; means for analyzing an input request; a means for learning based on a user's past material and preferences; A means for planning the generation of materials based on the learning results; a means of automatically generating appropriate figures and tables; a means for formatting and editing the generated figures and tables; means for storing the generated material and notifying the user; a means for receiving user feedback and updating the learning data; A system including:

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] In today's business environment, document creation is a frequent and important task that requires a great deal of time and effort. Demand for automation and efficiency tools is growing, especially with the increase in remote work. However, there is still a lack of tools that can automatically create personalized documents tailored to the user's preferences and style. Conventional tools have difficulty automatically generating appropriate figures and tables based on the user's past documents and preferences, and creating high-quality documents in a consistent style. [Means for solving the problem]

[0005] The present invention provides a system that allows a user to input a request for document creation, analyzes the requested content, learns the user's past documents and preferences, and automatically generates appropriate figures and tables and formats and edits the documents based on the input. Specifically, the system includes a means for a user to input a request for document creation, a means for analyzing the input request, a means for learning based on the user's past documents and preferences, a means for planning document creation based on the learning results, a means for automatically generating appropriate figures and tables, a means for formatting and editing the generated figures and tables, a means for saving the generated documents and notifying the user, and a means for receiving user feedback and updating the learning data. The system also includes a means for linking with a diagram generation API to generate appropriate figures and tables and a means for personalizing the documents to suit the user's preferences, enabling efficient and high-quality document creation.

[0006] "User" refers to a person or organization that utilizes the system to input a request for the creation of materials and receives the materials created in response to that request.

[0007] A "request" refers to a specific instruction entered by a user that includes the content and conditions required for creating a document.

[0008] "Analyzing" refers to the process of analyzing the input request using natural language processing or other methods to understand and classify its content.

[0009] "Learning" refers to the process of using a user's past data and preferences to extract patterns and features and train a model.

[0010] "Planning" refers to the process of determining the content and structure of the materials based on the learning results and analyzed requirements.

[0011] "Automatic generation" refers to the process by which the system artificially creates figures and tables based on specified conditions.

[0012] "Formatting and editing" refers to the process of arranging the generated figures and tables into an appropriate layout and format, and adjusting them to make them easier to read.

[0013] "Storing" refers to the process of storing the generated materials in a database or storage.

[0014] "Notifying" refers to the act of informing the user that the generated material is complete and available for use.

[0015] "Feedback" refers to evaluations and correction requests provided by users regarding generated materials.

[0016] "Updating the learning data" refers to the process of incorporating user feedback, adjusting the model and data again, and reflecting this in the next document creation.

[0017] "Chart Generation API" means an application programming interface for generating charts and tables based on specified criteria.

[0018] "Personalizing" refers to the process of individually optimizing the design and structure of materials based on the user's individual preferences and previous materials. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0027] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0040] The system of the present invention allows users to input their requirements for creating materials, automatically generates appropriate figures and tables based on those requirements, and provides the final materials. The program processing of this system is explained below in natural language, and specific examples are also provided.

[0041] System Overview

[0042] The system begins with the user inputting their document requirements, analyzes those requirements, and automatically generates high-quality documents based on the user's preferences. The server learns from the user's past documents and preferences, and based on that, creates an optimal plan for document generation, automatically generating appropriate figures and tables using a diagram generation API. The final document is saved and notified to the user. The system also incorporates user feedback to continuously improve it.

[0043] Detailed program processing

[0044] 1. User request input

[0045] Users use a terminal to input a document creation request, which includes the document title, the information to be included (e.g., schedule progress, budget utilization, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart).

[0046] The terminal transmits the request entered by the user to the server.

[0047] 2. Request Analysis

[0048] The server analyzes the received request, which involves identifying and classifying the request content (e.g., identifying the title, schedule progress, budget utilization, risk assessment, etc.).

[0049] The analysis results are stored in an internal data structure.

[0050] 3. Acquiring and analyzing user learning data

[0051] The server retrieves data about the user's past records and preferences from a database.

[0052] Using this data, natural language processing algorithms analyze user preferences and style, learning, for example, specific color tones, fonts, and layout patterns.

[0053] 4. Planning the data generation plan

[0054] Based on the learning results and the analyzed requirements, the server creates a plan for generating materials, detailing which charts to use and what content to include.

[0055] 5. Automatic generation of charts and graphs

[0056] The server sends a request to the chart generation API to generate the appropriate chart (e.g., Gantt chart, pie chart, quantitative table) based on the plan.

[0057] The chart generation API generates charts and tables according to the request and returns them to the server.

[0058] 6. Editing and formatting materials

[0059] The server places the generated figures and tables into a document template.

[0060] Based on the user's preferences, the design and layout are adjusted as necessary, for example, adjusting the order of figures and tables, color consistency, font style, etc.

[0061] The completed materials are converted into a document format (e.g. PDF, PPTX).

[0062] 7. Material Retention and Notification

[0063] The server stores the completed documents in a database.

[0064] The user is notified that the document is complete, including a link to the document and the file name.

[0065] 8. Processing feedback and updating learnings

[0066] The user uses the terminal to check the generated materials and input feedback if necessary.

[0067] The feedback provided by the user is sent to the server and analyzed.

[0068] The server updates the learning data based on the feedback and reflects it in the next document creation.

[0069] Specific examples

[0070] For example, consider the case where user A wants to create a progress report for a new project. User A enters the following request from his terminal:

[0071] Title: "Project A Progress Report"

[0072] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[0073] Preferred table or graph: "Gantt chart", "pie chart"

[0074] The server receives this request, learns from past documents and preferences, and creates a plan. It then automatically generates the necessary diagrams using a diagram generation API. The final report is formatted and edited in a format that suits User A's preferences, and User A is notified once it is complete. User A can review the completed document and provide feedback, which will be used to continuously improve the system.

[0075] In this way, the system of the present invention can efficiently create high-quality materials that meet the user's requirements.

[0076] The processing flow will be explained below.

[0077] Step 1:

[0078] The user inputs a document creation request from a terminal. The request includes the document title, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The terminal then sends the input request to the server.

[0079] Step 2:

[0080] The server parses the received request, identifying and categorizing the request content (e.g., identifying title, schedule progress, budget utilization, risk assessment, etc.), and stores the results of the analysis in an internal data structure.

[0081] Step 3:

[0082] The server retrieves data about the user's past materials and preferences from a database, including previously created reports and presentations, and the user's design preferences.

[0083] Step 4:

[0084] The server uses the acquired data to run natural language processing algorithms to analyze user preferences and style, learning specific color tones, fonts, layout patterns, etc.

[0085] Step 5:

[0086] Based on the learning results and the analyzed requirements, the server creates a plan for generating materials, detailing which charts to use and what content to include.

[0087] Step 6:

[0088] The server sends a request to the chart generation API to generate the appropriate chart (e.g., Gantt chart, pie chart, quantitative table) based on the plan. The chart generation API generates the chart or table according to the request and returns it to the server.

[0089] Step 7:

[0090] The server places the generated figures and tables into a document template, and adjusts the design and layout as needed based on the user's preferences, such as adjusting the order of figures and tables, color consistency, font style, etc.

[0091] Step 8:

[0092] The server converts the completed materials into a document format (e.g. PDF, PPTX), and once the materials have been formatted and edited, they are stored in the database.

[0093] Step 9:

[0094] The server notifies the user that the document is complete, including a link to the document and its file name.

[0095] Step 10:

[0096] The user can check the generated materials on the terminal and enter feedback if necessary, including suggestions for corrections and improvements.

[0097] Step 11:

[0098] The server receives and analyzes the user's feedback, updates the learning data based on the feedback, and reflects it in the next document creation.

[0099] Example 1

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

[0101] The conventional document creation process required a lot of time and effort, making it difficult to create efficient, high-quality documents quickly. Furthermore, it was difficult to automatically generate documents tailored to individual user preferences, creating a need for improved user satisfaction.

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

[0103] In this invention, the server includes means for inputting user requests, means for analyzing the requests, means for learning based on the user's past materials and preferences, means for planning material generation based on the learning results, means for automatically generating appropriate figures and tables, means for formatting and editing the generated figures and tables, means for saving the generated materials and notifying the user, means for receiving user feedback and updating the learning data, means for analyzing input from the terminal and creating a plan on the server, means for using a diagram generation API for automatically generating specific diagrams and tables, and means for arranging the automatically generated materials in a template and adjusting the design based on the user's preferences. This enables efficient and high-quality material creation and enables materials tailored to the preferences of individual users to be quickly provided.

[0104] A "user" is an entity that uses the system to input a request for material creation.

[0105] The "means for inputting requests" refers to a method or device that allows a user to provide the system with the information or requests required for creating materials.

[0106] "Means for analyzing requirements" is the process of breaking down input requirements, classifying them into specific categories, and understanding them.

[0107] "Means for learning based on the user's past materials and preferences" refers to a method for analyzing past materials and the user's usage history to understand the user's preferences and style.

[0108] "Means for planning material generation" is the process of creating a plan for how to compose materials based on the analyzed requirements and learning results.

[0109] "Means for automatically generating appropriate figures and tables" refers to a method for automatically creating figures and tables to be included in the materials.

[0110] A "diagram generation API" is a program interface that uses external services or software to generate diagrams in a specified format.

[0111] "Means for formatting and editing generated figures and tables" refers to methods for formatting automatically generated figures and tables, and is the process of adjusting the design and layout to suit the user's preferences.

[0112] The "means for storing the generated materials and notifying the user" refers to a method for safely storing the generated materials and notifying the user when the materials are completed.

[0113] "Means for receiving user feedback and updating learning data" refers to the process of collecting opinions and suggestions for improvement from users and improving the system's learning data based on them.

[0114] "Means for analyzing input from a terminal and creating a plan at a server" refers to a method in which a server receives a request input by a user through a terminal, analyzes it, and creates a plan for generating materials.

[0115] "Means for placing automatically generated materials in a template and adjusting the design based on the user's preferences" refers to the process of fitting the generated materials into a specified format and, if necessary, making design modifications to suit the user's preferences.

[0116] The system of the present invention starts when a user requests the creation of a document. The specific processing flow and operation of the system will be explained below.

[0117] A user uses a terminal to input a request for the creation of a document. The request includes the title of the document, the information to be included, the type of chart desired, etc. For example, when creating a project progress report, the user inputs the title "Project A Progress Report," information such as "Schedule Progress," "Budget Usage Status," and "Risk Assessment," as well as a request for charts such as a "Gantt Chart" or "Pie Chart."

[0118] The terminal sends the user's input to the server. The server analyzes the received request, breaks it down into a specific data structure, and stores it. Through the analysis, the request content (e.g., document title, schedule progress, budget usage, risk assessment, etc.) becomes clear.

[0119] The server then retrieves data about the user's past materials and preferences from a database and uses natural language processing algorithms to analyze the user's preferences and style, for example learning the font styles and color palettes the user has used in the past.

[0120] The server creates a plan for generating materials based on the learning results. This plan includes specific details such as which diagrams to place where and what content they should contain. After the plan is created, the server sends a request to the diagram generation API to generate the necessary diagrams (e.g., Gantt charts, pie charts).

[0121] The diagram generation API generates diagrams in the specified format in response to a request and returns the results to the server, which places the generated diagrams in a document template and adjusts the design and layout as needed based on the user's preferences, such as adjusting the diagram order, color matching, and font style.

[0122] The final document is converted into the specified document format (e.g., PDF, PPTX) and saved in the database by the server. The server notifies the user that the document is complete, and the notification includes a link to the document and its file name.

[0123] If the user wants to review the generated materials and provide feedback, they can enter it on their device. The feedback is sent to the server, which analyzes it and updates the system's learning data. This allows the feedback to be reflected the next time materials are created, allowing the system to continuously improve.

[0124] Examples of concrete examples and prompts

[0125] For example, consider a situation where user A wants to create a progress report for a new project. User A enters the following request into his terminal:

[0126] Title: "Project A Progress Report"

[0127] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[0128] Preferred table or graph: "Gantt chart", "pie chart"

[0129] Based on this request, the server generates the materials and provides the final report to User A. An example of a prompt sentence to input to the generative AI model is as follows:

[0130] I'd like to create a progress report for a new project. Please include the following required information:

[0131] Title: "Project A Progress Report"

[0132] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[0133] Preferred table or graph: "Gantt chart", "pie chart"

[0134] In this way, this system can efficiently create high-quality materials that meet the user's requirements.

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

[0136] Step 1:

[0137] The user inputs a request for material creation.

[0138] The user uses a terminal to input the title of the document, the information to be included, and the type of chart or diagram desired. For example, the user inputs the title "Project A Progress Report," the information to be included is "Schedule Progress," "Budget Usage Status," and "Risk Assessment," and the chart or diagram desired is "Gantt Chart" or "Pie Chart."

[0139] Input: Title of the document, information to include, desired type of chart

[0140] Output: User request data

[0141] Step 2:

[0142] The terminal sends the user's request to the server.

[0143] The terminal transmits the input request data to the server, which then receives the user's request for creating a document.

[0144] Input: User request data

[0145] Output: Sending the request data to the server

[0146] Step 3:

[0147] The server analyzes the request received from the user.

[0148] The server analyzes the request data, breaks down the request content into specific data structures, and stores them. For example, it identifies elements such as "title," "schedule progress," "budget usage," and "risk assessment."

[0149] Input: Request data

[0150] Output: Parsed request data

[0151] Step 4:

[0152] The server retrieves data about the user's past records and preferences from a database.

[0153] The server retrieves the user's past and preference data from a database and uses natural language processing algorithms to analyze the user's preferences and style, for example, learning specific font styles and color palettes.

[0154] Input: Parsed request data

[0155] Output: User's training data

[0156] Step 5:

[0157] The server creates a plan for generating materials based on the learning results.

[0158] The server creates a plan for generating materials based on the analyzed requests and learning results, including details such as which information to place in which charts.

[0159] Input: User training data

[0160] Output: Data generation plan

[0161] Step 6:

[0162] The server sends a request to the diagram generation API, requesting that a diagram be automatically generated based on the plan.

[0163] The server sends a request to the chart generation API, instructing it to generate charts such as Gantt charts, pie charts, etc. The chart generation API generates charts and tables according to the request and returns the results to the server.

[0164] Input: Data Generation Plan

[0165] Output: Generated chart data

[0166] Step 7:

[0167] The server places the generated diagrams and tables into a document template and adjusts the design and layout as needed.

[0168] The server places the generated diagrams into a document template and adjusts the design and layout based on the user's preferences, such as adjusting the diagram order, color consistency, and font style.

[0169] Input: Generated chart data

[0170] Output: Formatted and edited data

[0171] Step 8:

[0172] The server converts the completed materials into a document format and stores them in a database.

[0173] The server converts the formatted and edited data into PDF or PPTX format, stores it in the database, and notifies the user that the data is complete. The notification includes a link to the data and the file name.

[0174] Input: Formatted and edited data

[0175] Output: Documentation, user notifications

[0176] Step 9:

[0177] The user reviews the generated material and provides feedback.

[0178] The user can use the device to check the generated data and enter feedback as needed. For example, they can enter feedback such as "I would like the colors of the Gantt chart to be a little brighter." The feedback is sent from the device to the server.

[0179] Input: Generated materials, user feedback

[0180] Output: Feedback data

[0181] Step 10:

[0182] The server analyzes the feedback and updates the training data.

[0183] The server analyzes the feedback data and updates the system's learning data, so that the feedback is reflected in the next document creation, allowing the system to continuously improve.

[0184] Input: Feedback data

[0185] Output: Updated training data

[0186] The above are the specific operations and steps in the processing flow of the program of this system.

[0187] (Application example 1)

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

[0189] At logistics centers, managers need to accurately and quickly grasp inventory status and shipping progress, but manually collecting data and creating documents takes time and effort. It is also difficult to create reports based on past documents or in a format that suits the manager's preferences. This hinders efficient operations.

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

[0191] In this invention, the server includes: means for a user to input a request for document creation; means for analyzing the input request; means for learning based on the user's past documents and preferences; means for planning document creation based on the learning results; means for automatically generating appropriate figures and tables; means for formatting and editing the generated figures and tables; means for saving the generated documents and notifying the user; means for receiving user feedback and updating the learning data; means for acquiring necessary data from a database or API; means for performing data analysis and generating graphs; and means for linking with a business system to acquire data in real time. This enables managers to efficiently create high-quality reports and quickly grasp the operating status of the logistics center.

[0192] The "means for a user to input a request for creating a material" is an interface that allows a logged-in user to input a request for creating a material containing specific information.

[0193] The "means for analyzing the input request" is an algorithm for analyzing the content of the request for creating a document input by the user and identifying the type of data and charts required.

[0194] The "means for learning based on the user's past materials and preferences" is a machine learning model for learning based on materials created by the user in the past and the user's preferred designs and formats.

[0195] "Means for planning the generation of materials based on learning results" is a mechanism for planning the format in which materials should be created based on the learned data.

[0196] The "means for automatically generating appropriate figures and tables" is a software module for automatically generating necessary figures and tables based on the plan.

[0197] "Means for formatting and editing the generated figures and tables" refers to tools for formatting the generated figures and tables to fit the format of the document and adjusting the design as necessary.

[0198] "Means for saving generated materials and notifying users" refers to a system for saving completed materials and notifying users of their links or files.

[0199] The "means for receiving user feedback and updating learning data" is an algorithm for receiving feedback from users and reflecting that feedback in the next document creation.

[0200] "Means for obtaining necessary data from a database or API" refers to an interface for obtaining data necessary for document creation from a database or external API.

[0201] "Means for data analysis and graph generation" refers to the process for analyzing acquired data and generating graphs and tables in the format required for the report.

[0202] "Means of linking with business systems to obtain data in real time" refers to a mechanism that links with the logistics center's business systems to obtain the necessary data in real time.

[0203] The system of the present invention can automatically generate reports to support the work of a manager at a logistics center. A specific embodiment of the system will be described below.

[0204] System Configuration

[0205] This system mainly consists of a server, a user device (smartphone), various sensors, and an API. The server receives requests from users and manages a series of processes that automatically generate reports based on those requests. The user device is used to input requests for report creation and provide feedback.

[0206] Program processing overview

[0207] Hardware and Software

[0208] Hardware

[0209] server

[0210] Smartphone

[0211] Internet connection

[0212] Various sensors (inventory sensors, shipping sensors, etc.)

[0213] software

[0214] Flask (for the API)

[0215] Pandas (for data manipulation)

[0216] Matplotlib (for generating graphs)

[0217] Database management system (e.g., MySQL (registered trademark))

[0218] Chart generation API (e.g., Google® Charts API)

[0219] Detailed process description

[0220] 1. User request input

[0221] The user inputs a request for report creation using a smartphone, which specifically includes information such as "inventory status" and "shipping progress."

[0222] 2. Request Analysis

[0223] The server analyzes the request sent by the user and identifies the required data.

[0224] 3. Acquisition and analysis of training data

[0225] The server retrieves and analyzes data about the user's past materials and preferences from a database, thereby learning the user's preferences and style.

[0226] 4. Planning the data generation plan

[0227] Based on the learning results and requirements, plan the format in which the report will be prepared.

[0228] 5. Obtaining the necessary data

[0229] Get real-time inventory and shipping progress data from a database or API.

[0230] 6. Data analysis and graph generation

[0231] The acquired data is analyzed and charts (e.g., bar graphs, Pareto charts) are generated to show inventory status and shipping progress.

[0232] 7. Editing and formatting materials

[0233] The generated charts and graphs are formatted based on the report template, and the design is adjusted as necessary.

[0234] 8. Material Retention and Notification

[0235] The completed report is saved on an internet drive and the link is sent to the user.

[0236] 9. Get feedback and improve

[0237] It receives feedback from users, updates the learning data based on that feedback, and reflects it in subsequent report creation.

[0238] Specific examples

[0239] For example, if a logistics center manager wants to create a report that includes "This month's inventory status and shipping progress," he or she can enter the following request on a smartphone:

[0240] Prompt Sentence Examples

[0241] "Please prepare a report on this month's inventory status and shipping progress. Specifically, please include a bar graph of inventory and a Pareto chart of shipping status."

[0242] The server analyzes these requests, obtains the necessary information in real time, automatically generates a report, and notifies the manager. This system enables logistics center managers to efficiently create reports and quickly grasp the operational status.

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

[0244] Step 1: User enters a request for material creation

[0245] A user uses a smartphone to input a request to create a report. The request includes specific information (e.g., "This month's inventory status and shipping progress") and the desired type of chart (e.g., "Bar graph of inventory and Pareto chart of shipping status"). This input is sent from the device to the server.

[0246] Input: User request (e.g., "This month's inventory status and shipping progress")

[0247] Output: Request data containing the request content

[0248] Step 2: Parse the incoming request

[0249] The server receives the request sent by the user and begins analyzing it. During analysis, the request is identified and classified (e.g., "Stock status" or "Shipping progress"). At this stage, it is determined what data is required.

[0250] Input: Request data containing the requested content

[0251] Output: Analysis results (identification of required data)

[0252] Step 3: Obtain and analyze user learning data

[0253] The server retrieves data on past materials and user preferences from a database, and then uses natural language processing algorithms to analyze user preferences for design and formatting.

[0254] Input: Past data, user preference data

[0255] Output: Analysis of user preferences and styles

[0256] Step 4: Create a material generation plan

[0257] The server creates a report generation plan based on the analysis results and learning data, including the types and formats of charts and graphs to be used, and their display order.

[0258] Input: Analysis results, analysis of user preferences and style

[0259] Output: Report generation plan

[0260] Step 5: Get the data you need

[0261] The server retrieves the necessary inventory data and shipping progress data in real time from a database or external API based on the analysis results.

[0262] Input: Analysis results

[0263] Output: Inventory data, shipping progress data

[0264] Step 6: Analyze data and generate graphs

[0265] The server analyzes the acquired data and generates charts in the specified format (e.g., inventory bar graph, shipment Pareto chart). It uses Pandas to preprocess the data and Matplotlib to generate the charts.

[0266] Input: Inventory data, shipping progress data

[0267] Output: The generated diagram

[0268] Step 7: Edit and format your materials

[0269] The server includes the generated charts in a report, formats them based on a template, and makes any necessary design adjustments (color and font consistency).

[0270] Input: Generated charts, report generation plans

[0271] Output: A formatted report

[0272] Step 8: Save the material and notify users

[0273] The server stores the completed report and sends a link to the user via a smartphone application.

[0274] Input: Formatted report

[0275] Output: Saved report, notification link

[0276] Step 9: Get user feedback and update the training data

[0277] The user reviews the report and provides feedback, which the server receives and updates the learning data to reflect in future report generation.

[0278] Input: User feedback

[0279] Output: Updated training data, reflected in next data generation

[0280] The above are the specific processing steps and their contents. This system enables the logistics center manager to efficiently create high-quality reports and quickly grasp the operational status.

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

[0282] The system of the present invention allows users to input their document creation requirements, automatically generates appropriate figures and tables based on those requirements, and provides the final document. The system learns from the user's past documents and preferences, and uses this information to create an optimal plan for document generation. It then uses a diagram generation API to automatically generate diagrams as needed. The final document is saved and notified to the user. Furthermore, the system incorporates user feedback to continuously improve the system.

[0283] One of the features of this invention is the function of optimizing the document creation process according to the user's emotional state by combining it with an emotion engine that recognizes the user's emotions. Below, the program processing of this system is explained in natural language.

[0284] System Overview

[0285] The system receives the user's document creation request, analyzes it, learns from it, plans it, and then formats and edits the automatically generated figures and tables to provide the final document. In addition, it uses an emotion engine to recognize the user's emotional state and reflects the results in the design and content of the document.

[0286] Detailed program processing

[0287] 1. User request input

[0288] The user inputs a document creation request from a terminal. The request includes the document title, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The terminal then sends the request to the server.

[0289] 2. Request Analysis

[0290] The server parses the received request, identifying and categorizing the request content (e.g., identifying title, schedule progress, budget utilization, risk assessment, etc.), and stores the results of the analysis in an internal data structure.

[0291] 3. Acquiring and analyzing user learning data

[0292] The server retrieves data about the user's past materials and preferences from a database, including previously created reports and presentations, and the user's design preferences.

[0293] 4. Emotion recognition

[0294] The server utilizes an emotion engine to recognize the emotion of the user when inputting a request. The emotion engine analyzes the user's input and interactions and estimates their emotional state.

[0295] 5. Integrating learning outcomes and emotions

[0296] The server combines the acquired data with the results of emotion recognition and creates a plan for generating materials, taking into account the user's preferences and current emotional state. This plan details which charts to use and what content to include.

[0297] 6. Automatic generation of charts and graphs

[0298] The server sends a request to the chart generation API to generate the appropriate chart based on the plan, and the chart generation API generates charts and tables according to the request and returns them to the server.

[0299] 7. Editing and formatting materials

[0300] The server places the generated figures and tables into a document template, adjusting the design and layout as needed based on the user's preferences and emotional state. For example, if the user is feeling stressed, it will select a simple, easy-to-read layout.

[0301] 8. Material Retention and Notification

[0302] The server converts the completed materials into a document format (e.g. PDF, PPTX), and once the materials have been formatted and edited, they are stored in the database.

[0303] 9. Notification

[0304] The server notifies the user that the document is complete, including a link to the document and its file name.

[0305] 10. Processing feedback and updating learnings

[0306] The user can check the generated materials on the terminal and enter feedback if necessary, including suggestions for corrections and improvements.

[0307] The server receives user feedback, analyzes it, and updates the learning data based on the feedback and emotion engine data, which is then reflected in the next document creation.

[0308] Specific examples

[0309] For example, consider the case where user A wants to create a progress report for a new project. User A enters the following request from his terminal:

[0310] Title: "Project A Progress Report"

[0311] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[0312] Preferred table or graph: "Gantt chart", "pie chart"

[0313] Furthermore, the emotion engine recognizes that User A is nervous. The server integrates this emotion data with past document data to create an optimal plan. It then automatically generates appropriate diagrams using a diagram generation API. The final report is formatted and edited in a format that suits User A's preferences and current emotional state, and is notified to User A once it is complete. User A can provide feedback after checking the report, which further improves the system.

[0314] In this way, the system of the present invention can efficiently create high-quality materials that meet the user's needs and emotional state.

[0315] The processing flow will be explained below.

[0316] The system of the present invention allows users to input their document creation requirements, automatically generates appropriate figures and tables based on those requirements, and provides the final document. The system learns from the user's past documents and preferences, and uses this information to create an optimal plan for document generation. It then uses a diagram generation API to automatically generate diagrams as needed. The final document is saved and notified to the user. Furthermore, the system incorporates user feedback to continuously improve the system.

[0317] One of the features of this invention is the function of optimizing the document creation process according to the user's emotional state by combining it with an emotion engine that recognizes the user's emotions. Below, the program processing of this system is explained in natural language.

[0318] Step 1:

[0319] The user inputs a document creation request from a terminal. The request includes the document title, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The terminal then sends the input request to the server.

[0320] Step 2:

[0321] The server parses the received request, identifying and categorizing the request content (e.g., identifying title, schedule progress, budget utilization, risk assessment, etc.), and stores the results of the analysis in an internal data structure.

[0322] Step 3:

[0323] The server retrieves data about the user's past materials and preferences from a database, including previously created reports and presentations, and the user's design preferences.

[0324] Step 4:

[0325] The server uses the acquired data to run natural language processing algorithms to analyze user preferences and style, learning specific color tones, fonts, layout patterns, etc.

[0326] Step 5:

[0327] The server utilizes an emotion engine to recognize the emotion of the user when inputting a request. The emotion engine analyzes the user's input and interactions, and estimates and classifies their emotional state (e.g., stress, joy, excitement, etc.).

[0328] Step 6:

[0329] The server combines the acquired data with the results of emotion recognition and creates a plan for generating materials, taking into account the user's preferences and current emotional state. This plan details which charts to use and what content to include.

[0330] Step 7:

[0331] The server sends a request to the chart generation API, which generates the appropriate charts based on the plan. The chart generation API generates charts and tables according to the request and returns them to the server.

[0332] Step 8:

[0333] The server places the generated figures and tables into a document template, adjusting the design and layout based on the user's preferences and emotional state. For example, if the user is feeling stressed, a simple, easy-to-read layout and a calm color scheme are selected.

[0334] Step 9:

[0335] The server converts the material into a document format (e.g. PDF, PPTX), and once formatting and editing are complete, it stores the resulting material in a database.

[0336] Step 10:

[0337] The server notifies the user that the document is complete, including a link to the document and its file name.

[0338] Step 11:

[0339] The user can check the generated materials on the terminal and enter feedback if necessary, including suggestions for corrections and improvements.

[0340] Step 12:

[0341] The server receives user feedback, analyzes it, and updates the learning data based on the feedback and emotion engine data, which is then reflected in the next document creation.

[0342] As a concrete example, let us consider the case where User A is creating a progress report for a new project. User A inputs the following requests from the terminal: "Project A Progress Report", "Schedule Progress", "Budget Usage", "Risk Assessment", "Gantt Chart" and "Pie Chart". The emotion engine recognizes that User A is nervous.

[0343] The server integrates this emotional data with past document data to create an optimal plan. It then automatically generates the necessary diagrams using a diagram generation API. The final report is formatted and edited in a format that matches User A's preferences and current emotional state. Once completed, User A is notified, and User A can provide feedback after reviewing the report, which further improves the system. In this way, the system of the present invention can efficiently create high-quality documents that meet the user's requests and emotional state.

[0344] Example 2

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

[0346] In today's business environment, efficient and high-quality document creation is essential. However, conventional document creation processes require a great deal of time and effort, making it difficult to create documents that reflect the user's preferences and emotional state. Meanwhile, there is a problem in that methods for automatically generating appropriate figures and tables and providing them in an optimal format to the user are not functioning effectively. The present invention aims to provide a system that automatically generates efficient, personalized documents that take into account the user's preferences and emotional state.

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

[0348] In this invention, the server includes means for a user to input a request for creating a document, means for analyzing the input request, means for learning based on the user's past documents and preferences, means for planning document creation based on the learning results, means for automatically generating appropriate figures and tables, means for formatting and editing the generated figures and tables, means for saving the generated documents and notifying the user, means for receiving user feedback and updating the learning data, and means for recognizing the user's emotional state and optimizing the document creation process based on the emotion. This enables efficient creation of high-quality documents according to the user's request and emotional state.

[0349] The "means for users to input requests for creating materials" refers to an interface that allows users to input requests to the system via a terminal by specifying the title of the material, the information to be included, the type of charts and diagrams desired, etc.

[0350] The "means for analyzing input requests" refers to a processing function that analyzes the document creation request received by the server from the user and identifies and classifies the title, included information, type of chart, etc.

[0351] "Means for learning based on the user's past data and preferences" refers to a function in which the server retrieves the user's past data and preference data from a database, analyzes it, and learns the user's patterns and preferences.

[0352] The "means for planning material generation based on learning results" is a function that combines acquired learning data with information on emotional state to formulate an optimal material generation plan.

[0353] The "means for automatically generating appropriate charts and tables" is a function in which the server uses a chart generation API to automatically create appropriate charts and tables based on the user's requests and plans.

[0354] "Means for formatting and editing the generated figures and tables" refers to a function in which the server places the generated figures and tables in a document template and adjusts the layout and design to suit the user's preferences and emotional state.

[0355] The "means for saving the generated materials and notifying the user" is a function for converting the completed materials into a specified document format, saving them in a database, and sending a notification to inform the user.

[0356] The "means for receiving user feedback and updating learning data" is a function that analyzes the feedback provided by the user regarding the generated materials, updates the learning data based on that feedback, and reflects it in the next material creation.

[0357] "Means for recognizing the user's emotional state and optimizing the document creation process based on that emotion" is a function that uses an emotion engine to recognize the user's emotional state and reflects that information in the document creation process to optimize it.

[0358] "Figure Generation API" is an application program interface for generating figures and tables used in materials.

[0359] The system of the present invention is an information processing system in which a user inputs a request for creating a document, and appropriate figures and tables are automatically generated based on the request, and the final document is provided. A description will now be given of an embodiment of the present invention.

[0360] First, a user inputs a request for document creation using a terminal. This request includes the title of the document, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The input information is sent from the terminal to the server.

[0361] The server analyzes the received request. Specifically, it identifies the request content and classifies and extracts information such as the title and schedule progress. The results of this analysis are stored in an internal data structure.

[0362] The server then retrieves data about the user's past documents and preferences from a database, including past reports and presentations, the user's design preferences, etc. The server analyzes this data to learn the user's patterns and preferences.

[0363] The server also uses an emotion engine to recognize the user's emotional state. The emotion engine estimates the user's emotional state based on the user's input and interactions and provides the results to the server. For example, it can recognize the user's level of tension when inputting information.

[0364] By integrating the acquired training data and the emotion recognition results, the server creates an optimal plan for generating materials, which details which charts to use and what content to include.

[0365] The server then sends a request to the chart generation API to generate the appropriate charts and tables based on the plan. The chart generation API generates the charts and tables according to the request and sends the results back to the server.

[0366] The server then places the generated diagrams into a document template, adjusting the design and layout as needed based on the user's preferences and emotional state. For example, if the user is feeling stressed, a simple, easy-to-read layout is selected.

[0367] The completed document is converted into a document format (e.g., PDF, PPTX) by the server and saved in the database. The server then notifies the user that the document is complete. The notification includes the document link and file name.

[0368] The user checks the completed document and provides feedback as needed. The server receives the feedback, analyzes the content, and updates the learning data, which is then reflected in the next document creation.

[0369] As a concrete example, consider the case where user A wants to create a progress report for a new project. User A enters the following request into the terminal:

[0370] Title: "Project A Progress Report"

[0371] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[0372] Preferred table or graph: "Gantt chart", "pie chart"

[0373] Furthermore, the emotion engine recognizes that User A is nervous. The server integrates this emotion data with past document data to create an optimal plan. It then automatically generates an appropriate diagram using a diagram generation API. The final report is formatted and edited in a format that suits User A's preferences and current emotional state, and is notified to User A once it is complete. User A can provide feedback after reviewing the report, further improving the system.

[0374] In this way, the system of the present invention can efficiently create high-quality materials that meet the user's needs and emotional state.

[0375] Example prompt sentence:

[0376] Create a progress report for Project A. Include information on schedule progress, budget utilization, and risk assessment. Gantt charts and pie charts are preferred for tables and graphs. Also, consider the user's emotional state and adjust the layout to be simple and easy to read.

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

[0378] Step 1:

[0379] User request input

[0380] Specific operation: The user inputs a request for creating a document from the terminal.

[0381] Input: Title, information to include (e.g., schedule progress, budget usage, risk assessment), desired chart type (e.g., Gantt chart, pie chart).

[0382] Output: The request data sent from the device to the server.

[0383] Data processing / data calculation: The terminal collects user input and sends it to the server as structured request data.

[0384] Step 2:

[0385] Parsing the request

[0386] Specific operation: The server analyzes the received request.

[0387] Input: The request data received in step 1.

[0388] Output: An internal data structure containing the analysis results.

[0389] Data processing / data calculation: The server identifies the requested content and classifies and extracts the title and each information item.

[0390] Step 3:

[0391] Acquiring and analyzing user learning data

[0392] What it does: The server retrieves data about the user's past records and preferences from a database.

[0393] Input: User ID or historical material identification.

[0394] Output: Analysis of user's historical data and preferences.

[0395] Data processing / data calculation: The server retrieves the user's past material information from the database and analyzes the data to learn patterns and preferences.

[0396] Step 4:

[0397] emotion recognition

[0398] Specific operation: The server uses the emotion engine to recognize the emotion when the user inputs a request.

[0399] Input: User input and interaction data.

[0400] Output: Data indicating the user's emotional state.

[0401] Data processing / data calculation: The emotion engine analyzes input data and estimates the emotional state.

[0402] Step 5:

[0403] Integrating learning outcomes and emotions

[0404] Specific operation: The server integrates the acquired training data with the emotion recognition results.

[0405] Input: User preference analysis results and emotional state data.

[0406] Output: Planning data for material generation.

[0407] Data processing / data calculation: The server formulates an optimal plan for generating materials, taking into account the user's preferences and emotional state.

[0408] Step 6:

[0409] Automatic chart generation

[0410] Specific operation: The server sends a request to the chart generation API to generate the appropriate chart.

[0411] Input: Planning data for material generation.

[0412] Output: The generated chart data.

[0413] Data processing / data calculation: The chart generation API generates appropriate charts and tables based on the request and returns the data to the server.

[0414] Step 7:

[0415] Editing and formatting materials

[0416] Specific operation: The server places the generated figures and tables into the document template and adjusts the design and layout.

[0417] Input: Generated diagram data and user preference and emotional state data.

[0418] Output: Formatted and edited data.

[0419] Data processing / data calculation: The server places figures and tables on the template and adjusts the layout and design as needed.

[0420] Step 8:

[0421] Material Retention and Notification

[0422] Specific operation: The server converts the completed materials into a document format and stores them in the database.

[0423] Input: Formatted and edited data.

[0424] Output: Document data in document format (e.g. PDF, PPTX) and notification of completion of saving.

[0425] Data processing / data calculation: The server converts the material data into the specified document format and stores it in the database.

[0426] Step 9:

[0427] notification

[0428] Specific operation: The server notifies the user that the document is complete.

[0429] Input: Saved material data.

[0430] Output: A notification message to the user.

[0431] Data processing / data calculation: The server generates a notification message and sends it to the user, including the link and file name of the material.

[0432] Step 10:

[0433] Processing feedback and updating learnings

[0434] Specific operation: The user reviews the generated materials and provides feedback. The server receives the feedback, analyzes it, and updates the learning data.

[0435] Input: User feedback data.

[0436] Output: Updated training data.

[0437] Data processing / data calculation: The server analyzes the feedback, reflects the content in the learning data, and applies it to the next document creation.

[0438] (Application example 2)

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

[0440] In modern factories, many robots are in operation, and managing them requires a great deal of time and effort. Furthermore, the emotions and stress levels of managers often affect the quality of their work. A method is needed to solve these problems and generate efficient, user-friendly robot management reports.

[0441] 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 a user to input a request for document creation; means for analyzing the input request; means for learning based on the user's past documents and preferences; means for planning document creation based on the learning results; means for automatically generating appropriate figures and tables; means for formatting and editing the generated figures and tables; means for saving the generated documents and notifying the user; means for receiving user feedback and updating the learning data; and means for including an emotion recognition engine that recognizes the user's emotional state and adjusting the design and content of the documents according to the emotional state. This enables efficient and high-quality robot management reports to be generated while taking into account the emotional state of the manager.

[0442] The "means for the user to input a request for material creation" refers to an interface through which the user inputs specific requests for material creation using his / her own terminal.

[0443] The "means for analyzing an input request" refers to a software module that analyzes a request input by a user and identifies and classifies the request content.

[0444] "Means for learning based on the user's past materials and preferences" refers to an algorithm that acquires the user's past material data and preference patterns stored in a database and learns from them using a machine learning model.

[0445] "Means for planning the generation of materials based on learning results" refers to a planning module that plans what information to include in the materials and in what format based on learning results.

[0446] "Means for automatically generating appropriate figures and tables" refers to a function that uses a chart generation API based on a plan to automatically generate appropriate figures and tables.

[0447] "Means for formatting and editing the generated figures and tables" refers to software tools that are used to format the generated figures and tables to fit the design and layout of the document and make any necessary edits.

[0448] "Means for saving the generated materials and notifying the user" refers to a communication module that saves the completed materials in a database and notifies the user of the link and file name.

[0449] The "means for receiving user feedback and updating learning data" refers to a control program that receives feedback from users, analyzes the content of the feedback, and updates the learning data.

[0450] "Means for adjusting the design and content of materials according to the emotional state, including an emotion recognition engine" refers to an engine that analyzes the user's emotions and an algorithm that optimizes the design and content of materials according to the emotional state.

[0451] This invention is a system for efficiently managing robot operation data and maintenance information in factory management, thereby reducing the stress of managers. This system is implemented through the following steps.

[0452] System Overview:

[0453] The system receives requests for document creation from users, analyzes them, learns from them, plans them, automatically generates appropriate diagrams and tables, and finally provides them as documents. During this process, it uses an emotion recognition engine to recognize the user's emotional state and optimize the document creation process.

[0454] Hardware and software:

[0455] Smartphone: Used by the user to input requests for material creation.

[0456] Head-mounted display: Used by the user to view the generated materials.

[0457] Emotion recognition engine: Software that analyzes user input and recognizes their emotional state.

[0458] Chart generation API: An API for automatically generating charts and tables based on your requests.

[0459] Databases (e.g., Firebase): Used to store and retrieve user history and preferences.

[0460] Notification Service: A service for notifying users of the link and file name of the completed document.

[0461] Examples:

[0462] When a user wants to create a new robot operation report, they use their smartphone to enter the following request:

[0463] Title: "Robot Operation Report"

[0464] Information included: "Operating time", "Failure rate", "Maintenance history"

[0465] Desired table or graph: "Bar chart", "Pie chart"

[0466] The server analyzes this request and learns from the user's past materials and preferences. It also uses an emotion recognition engine to recognize the user's emotional state (e.g., tension or stress). It then creates a material generation plan that takes into account the learning results and the user's emotional state. Based on this plan, it automatically generates appropriate diagrams and tables using a diagram generation API.

[0467] The generated diagrams and tables are formatted and edited in a design optimized for the user's emotional state and saved as the final document in the database. Once the document is complete, a notification is sent to the user via a notification service. The system is continuously improved as users review the document and provide feedback.

[0468] Example prompt sentence:

[0469] "We understand that users are nervous. Please generate a simple, easy-to-read 'Robot Operation Report' for them. The report should include bar charts and pie charts with uptime, failure rate, and maintenance history."

[0470] In this way, the system can take into account the emotional state of the manager and automatically generate efficient and high-quality robot management reports, thereby reducing the burden of work.

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

[0472] Step 1:

[0473] The user inputs a request for document creation. Using a terminal, the user inputs the document title, the information to be included, the desired type of chart, etc. This input data is sent to the server. The input data includes "robot operation report," "operation time," "failure rate," "maintenance history," "bar chart," "pie chart," etc.

[0474] Step 2:

[0475] The server analyzes the input request. The server analyzes the received request data and identifies the document title, the information to be included, the desired type of chart, etc. The analysis results are stored in an internal data structure. For example, the server identifies "Robot Operation Report" as the title and classifies "Operation Hours," "Failure Rate," and "Maintenance History" as the required information.

[0476] Step 3:

[0477] The server learns based on the user's past data and preferences. The server retrieves the user's past data and design preferences from a database. This data is input into a machine learning algorithm to learn the user's preferences and trends. For example, it analyzes past robot reports and design patterns.

[0478] Step 4:

[0479] The server creates a plan for generating materials based on the learning results. Based on the acquired data and the learned user preferences, it plans what information to include in the materials and in what format. This plan may include, for example, using a bar chart for "operating time" and a pie chart for "failure rate."

[0480] Step 5:

[0481] The server uses an emotion recognition engine to recognize the user's emotional state. It analyzes the user's typing speed and click patterns to estimate their emotional state, such as tension or stress. The results are used to adjust the design and content of the materials.

[0482] Step 6:

[0483] The server automatically generates the appropriate charts and tables. Based on the plan, it sends a request to the chart generation API to generate the necessary charts (bar charts and pie charts). For example, it generates a bar chart using the "uptime" data and a pie chart using the "failure rate" data.

[0484] Step 7:

[0485] The server formats and edits the generated diagrams and tables. It places the generated diagrams and tables into a document template and adjusts the design and layout based on the user's emotional state. For example, if the user is nervous, it will create a simple, easy-to-read layout.

[0486] Step 8:

[0487] The server saves the generated document and notifies the user. The server saves the final document in PDF or PPTX format and notifies the user of the link and file name. The notification includes a download link for the generated document.

[0488] Step 9:

[0489] The user provides feedback. Through the terminal, the user inputs feedback on the generated materials. The feedback includes corrections and improvements.

[0490] Step 10:

[0491] The server analyzes user feedback and updates the learning data. The provided feedback is analyzed and reflected in the next data generation along with the emotion engine data. This allows the system to continuously improve.

[0492] This series of steps enables efficient and high-quality robot management reports to be automatically generated while taking into consideration the user's emotional state.

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

[0494] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (registered trademark) (Internet search engine).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (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.

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

[0496] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0509] The system of the present invention allows users to input their requirements for creating materials, automatically generates appropriate figures and tables based on those requirements, and provides the final materials. The program processing of this system is explained below in natural language, and specific examples are also provided.

[0510] System Overview

[0511] The system begins with the user inputting their document requirements, analyzes those requirements, and automatically generates high-quality documents based on the user's preferences. The server learns from the user's past documents and preferences, and based on that, creates an optimal plan for document generation, automatically generating appropriate figures and tables using a diagram generation API. The final document is saved and notified to the user. The system also incorporates user feedback to continuously improve it.

[0512] Detailed program processing

[0513] 1. User request input

[0514] Users use a terminal to input a document creation request, which includes the document title, the information to be included (e.g., schedule progress, budget utilization, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart).

[0515] The terminal transmits the request entered by the user to the server.

[0516] 2. Request Analysis

[0517] The server analyzes the received request, which involves identifying and classifying the request content (e.g., identifying the title, schedule progress, budget utilization, risk assessment, etc.).

[0518] The analysis results are stored in an internal data structure.

[0519] 3. Acquiring and analyzing user learning data

[0520] The server retrieves data about the user's past records and preferences from a database.

[0521] Using this data, natural language processing algorithms analyze user preferences and style, learning, for example, specific color tones, fonts, and layout patterns.

[0522] 4. Planning the data generation plan

[0523] Based on the learning results and the analyzed requirements, the server creates a plan for generating materials, detailing which charts to use and what content to include.

[0524] 5. Automatic generation of charts and graphs

[0525] The server sends a request to the chart generation API to generate the appropriate chart (e.g., Gantt chart, pie chart, quantitative table) based on the plan.

[0526] The chart generation API generates charts and tables according to the request and returns them to the server.

[0527] 6. Editing and formatting materials

[0528] The server places the generated figures and tables into a document template.

[0529] Based on the user's preferences, the design and layout are adjusted as necessary, for example, adjusting the order of figures and tables, color consistency, font style, etc.

[0530] The completed materials are converted into a document format (e.g. PDF, PPTX).

[0531] 7. Material Retention and Notification

[0532] The server stores the completed documents in a database.

[0533] The user is notified that the document is complete, including a link to the document and the file name.

[0534] 8. Processing feedback and updating learnings

[0535] The user uses the terminal to check the generated materials and input feedback if necessary.

[0536] The feedback provided by the user is sent to the server and analyzed.

[0537] The server updates the learning data based on the feedback and reflects it in the next document creation.

[0538] Specific examples

[0539] For example, consider the case where user A wants to create a progress report for a new project. User A enters the following request from his terminal:

[0540] Title: "Project A Progress Report"

[0541] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[0542] Preferred table or graph: "Gantt chart", "pie chart"

[0543] The server receives this request, learns from past documents and preferences, and creates a plan. It then automatically generates the necessary diagrams using a diagram generation API. The final report is formatted and edited in a format that suits User A's preferences, and User A is notified once it is complete. User A can review the completed document and provide feedback, which will be used to continuously improve the system.

[0544] In this way, the system of the present invention can efficiently create high-quality materials that meet the user's requirements.

[0545] The processing flow will be explained below.

[0546] Step 1:

[0547] The user inputs a document creation request from a terminal. The request includes the document title, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The terminal then sends the input request to the server.

[0548] Step 2:

[0549] The server parses the received request, identifying and categorizing the request content (e.g., identifying title, schedule progress, budget utilization, risk assessment, etc.), and stores the results of the analysis in an internal data structure.

[0550] Step 3:

[0551] The server retrieves data about the user's past materials and preferences from a database, including previously created reports and presentations, and the user's design preferences.

[0552] Step 4:

[0553] The server uses the acquired data to run natural language processing algorithms to analyze user preferences and style, learning specific color tones, fonts, layout patterns, etc.

[0554] Step 5:

[0555] Based on the learning results and the analyzed requirements, the server creates a plan for generating materials, detailing which charts to use and what content to include.

[0556] Step 6:

[0557] The server sends a request to the chart generation API to generate the appropriate chart (e.g., Gantt chart, pie chart, quantitative table) based on the plan. The chart generation API generates the chart or table according to the request and returns it to the server.

[0558] Step 7:

[0559] The server places the generated figures and tables into a document template, and adjusts the design and layout as needed based on the user's preferences, such as adjusting the order of figures and tables, color consistency, font style, etc.

[0560] Step 8:

[0561] The server converts the completed materials into a document format (e.g. PDF, PPTX), and once the materials have been formatted and edited, they are stored in the database.

[0562] Step 9:

[0563] The server notifies the user that the document is complete, including a link to the document and its file name.

[0564] Step 10:

[0565] The user can check the generated materials on the terminal and enter feedback if necessary, including suggestions for corrections and improvements.

[0566] Step 11:

[0567] The server receives and analyzes the user's feedback, updates the learning data based on the feedback, and reflects it in the next document creation.

[0568] Example 1

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

[0570] The conventional document creation process required a lot of time and effort, making it difficult to create efficient, high-quality documents quickly. Furthermore, it was difficult to automatically generate documents tailored to individual user preferences, creating a need for improved user satisfaction.

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

[0572] In this invention, the server includes means for inputting user requests, means for analyzing the requests, means for learning based on the user's past materials and preferences, means for planning material generation based on the learning results, means for automatically generating appropriate figures and tables, means for formatting and editing the generated figures and tables, means for saving the generated materials and notifying the user, means for receiving user feedback and updating the learning data, means for analyzing input from the terminal and creating a plan on the server, means for using a diagram generation API for automatically generating specific diagrams and tables, and means for arranging the automatically generated materials in a template and adjusting the design based on the user's preferences. This enables efficient and high-quality material creation and enables materials tailored to the preferences of individual users to be quickly provided.

[0573] A "user" is an entity that uses the system to input a request for material creation.

[0574] The "means for inputting requests" refers to a method or device that allows a user to provide the system with the information or requests required for creating materials.

[0575] "Means for analyzing requirements" is the process of breaking down input requirements, classifying them into specific categories, and understanding them.

[0576] "Means for learning based on the user's past materials and preferences" refers to a method for analyzing past materials and the user's usage history to understand the user's preferences and style.

[0577] "Means for planning material generation" is the process of creating a plan for how to compose materials based on the analyzed requirements and learning results.

[0578] "Means for automatically generating appropriate figures and tables" refers to a method for automatically creating figures and tables to be included in the materials.

[0579] A "diagram generation API" is a program interface that uses external services or software to generate diagrams in a specified format.

[0580] "Means for formatting and editing generated figures and tables" refers to methods for formatting automatically generated figures and tables, and is the process of adjusting the design and layout to suit the user's preferences.

[0581] The "means for storing the generated materials and notifying the user" refers to a method for safely storing the generated materials and notifying the user when the materials are completed.

[0582] "Means for receiving user feedback and updating learning data" refers to the process of collecting opinions and suggestions for improvement from users and improving the system's learning data based on them.

[0583] "Means for analyzing input from a terminal and creating a plan at a server" refers to a method in which a server receives a request input by a user through a terminal, analyzes it, and creates a plan for generating materials.

[0584] "Means for placing automatically generated materials in a template and adjusting the design based on the user's preferences" refers to the process of fitting the generated materials into a specified format and, if necessary, making design modifications to suit the user's preferences.

[0585] The system of the present invention starts when a user requests the creation of a document. The specific processing flow and operation of the system will be explained below.

[0586] A user uses a terminal to input a request for the creation of a document. The request includes the title of the document, the information to be included, the type of chart desired, etc. For example, when creating a project progress report, the user inputs the title "Project A Progress Report," information such as "Schedule Progress," "Budget Usage Status," and "Risk Assessment," as well as a request for charts such as a "Gantt Chart" or "Pie Chart."

[0587] The terminal sends the user's input to the server. The server analyzes the received request, breaks it down into a specific data structure, and stores it. Through the analysis, the request content (e.g., document title, schedule progress, budget usage, risk assessment, etc.) becomes clear.

[0588] The server then retrieves data about the user's past materials and preferences from a database and uses natural language processing algorithms to analyze the user's preferences and style, for example learning the font styles and color palettes the user has used in the past.

[0589] The server creates a plan for generating materials based on the learning results. This plan includes specific details such as which diagrams to place where and what content they should contain. After the plan is created, the server sends a request to the diagram generation API to generate the necessary diagrams (e.g., Gantt charts, pie charts).

[0590] The diagram generation API generates diagrams in the specified format in response to a request and returns the results to the server, which places the generated diagrams in a document template and adjusts the design and layout as needed based on the user's preferences, such as adjusting the diagram order, color matching, and font style.

[0591] The final document is converted into the specified document format (e.g., PDF, PPTX) and saved in the database by the server. The server notifies the user that the document is complete, and the notification includes a link to the document and its file name.

[0592] If the user wants to review the generated materials and provide feedback, they can enter it on their device. The feedback is sent to the server, which analyzes it and updates the system's learning data. This allows the feedback to be reflected the next time materials are created, allowing the system to continuously improve.

[0593] Examples of concrete examples and prompts

[0594] For example, consider a situation where user A wants to create a progress report for a new project. User A enters the following request into his terminal:

[0595] Title: "Project A Progress Report"

[0596] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[0597] Preferred table or graph: "Gantt chart", "pie chart"

[0598] Based on this request, the server generates the materials and provides the final report to User A. An example of a prompt sentence to input to the generative AI model is as follows:

[0599] I'd like to create a progress report for a new project. Please include the following required information:

[0600] Title: "Project A Progress Report"

[0601] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[0602] Preferred table or graph: "Gantt chart", "pie chart"

[0603] In this way, this system can efficiently create high-quality materials that meet the user's requirements.

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

[0605] Step 1:

[0606] The user inputs a request for material creation.

[0607] The user uses a terminal to input the title of the document, the information to be included, and the type of chart or diagram desired. For example, the user inputs the title "Project A Progress Report," the information to be included is "Schedule Progress," "Budget Usage Status," and "Risk Assessment," and the chart or diagram desired is "Gantt Chart" or "Pie Chart."

[0608] Input: Title of the document, information to include, desired type of chart

[0609] Output: User request data

[0610] Step 2:

[0611] The terminal sends the user's request to the server.

[0612] The terminal transmits the input request data to the server, which then receives the user's request for creating a document.

[0613] Input: User request data

[0614] Output: Sending the request data to the server

[0615] Step 3:

[0616] The server analyzes the request received from the user.

[0617] The server analyzes the request data, breaks down the request content into specific data structures, and stores them. For example, it identifies elements such as "title," "schedule progress," "budget usage," and "risk assessment."

[0618] Input: Request data

[0619] Output: Parsed request data

[0620] Step 4:

[0621] The server retrieves data about the user's past records and preferences from a database.

[0622] The server retrieves the user's past and preference data from a database and uses natural language processing algorithms to analyze the user's preferences and style, for example, learning specific font styles and color palettes.

[0623] Input: Parsed request data

[0624] Output: User's training data

[0625] Step 5:

[0626] The server creates a plan for generating materials based on the learning results.

[0627] The server creates a plan for generating materials based on the analyzed requests and learning results, including details such as which information to place in which charts.

[0628] Input: User training data

[0629] Output: Data generation plan

[0630] Step 6:

[0631] The server sends a request to the diagram generation API, requesting that a diagram be automatically generated based on the plan.

[0632] The server sends a request to the chart generation API, instructing it to generate charts such as Gantt charts, pie charts, etc. The chart generation API generates charts and tables according to the request and returns the results to the server.

[0633] Input: Data Generation Plan

[0634] Output: Generated chart data

[0635] Step 7:

[0636] The server places the generated diagrams and tables into a document template and adjusts the design and layout as needed.

[0637] The server places the generated diagrams into a document template and adjusts the design and layout based on the user's preferences, such as adjusting the diagram order, color consistency, and font style.

[0638] Input: Generated chart data

[0639] Output: Formatted and edited data

[0640] Step 8:

[0641] The server converts the completed materials into a document format and stores them in a database.

[0642] The server converts the formatted and edited data into PDF or PPTX format, stores it in the database, and notifies the user that the data is complete. The notification includes a link to the data and the file name.

[0643] Input: Formatted and edited data

[0644] Output: Documentation, user notifications

[0645] Step 9:

[0646] The user reviews the generated material and provides feedback.

[0647] The user can use the device to check the generated data and enter feedback as needed. For example, they can enter feedback such as "I would like the colors of the Gantt chart to be a little brighter." The feedback is sent from the device to the server.

[0648] Input: Generated materials, user feedback

[0649] Output: Feedback data

[0650] Step 10:

[0651] The server analyzes the feedback and updates the training data.

[0652] The server analyzes the feedback data and updates the system's learning data, so that the feedback is reflected in the next document creation, allowing the system to continuously improve.

[0653] Input: Feedback data

[0654] Output: Updated training data

[0655] The above are the specific operations and steps in the processing flow of the program of this system.

[0656] (Application example 1)

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

[0658] At logistics centers, managers need to accurately and quickly grasp inventory status and shipping progress, but manually collecting data and creating documents takes time and effort. It is also difficult to create reports based on past documents or in a format that suits the manager's preferences. This hinders efficient operations.

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

[0660] In this invention, the server includes: means for a user to input a request for document creation; means for analyzing the input request; means for learning based on the user's past documents and preferences; means for planning document creation based on the learning results; means for automatically generating appropriate figures and tables; means for formatting and editing the generated figures and tables; means for saving the generated documents and notifying the user; means for receiving user feedback and updating the learning data; means for acquiring necessary data from a database or API; means for performing data analysis and generating graphs; and means for linking with a business system to acquire data in real time. This enables managers to efficiently create high-quality reports and quickly grasp the operating status of the logistics center.

[0661] The "means for a user to input a request for creating a material" is an interface that allows a logged-in user to input a request for creating a material containing specific information.

[0662] The "means for analyzing the input request" is an algorithm for analyzing the content of the request for creating a document input by the user and identifying the type of data and charts required.

[0663] The "means for learning based on the user's past materials and preferences" is a machine learning model for learning based on materials created by the user in the past and the user's preferred designs and formats.

[0664] "Means for planning the generation of materials based on learning results" is a mechanism for planning the format in which materials should be created based on the learned data.

[0665] The "means for automatically generating appropriate figures and tables" is a software module for automatically generating necessary figures and tables based on the plan.

[0666] "Means for formatting and editing the generated figures and tables" refers to tools for formatting the generated figures and tables to fit the format of the document and adjusting the design as necessary.

[0667] "Means for saving generated materials and notifying users" refers to a system for saving completed materials and notifying users of their links or files.

[0668] The "means for receiving user feedback and updating learning data" is an algorithm for receiving feedback from users and reflecting that feedback in the next document creation.

[0669] "Means for obtaining necessary data from a database or API" refers to an interface for obtaining data necessary for document creation from a database or external API.

[0670] "Means for data analysis and graph generation" refers to the process for analyzing acquired data and generating graphs and tables in the format required for the report.

[0671] "Means of linking with business systems to obtain data in real time" refers to a mechanism that links with the logistics center's business systems to obtain the necessary data in real time.

[0672] The system of the present invention can automatically generate reports to support the work of a manager at a logistics center. A specific embodiment of the system will be described below.

[0673] System Configuration

[0674] This system mainly consists of a server, a user device (smartphone), various sensors, and an API. The server receives requests from users and manages a series of processes that automatically generate reports based on those requests. The user device is used to input requests for report creation and provide feedback.

[0675] Program processing overview

[0676] Hardware and Software

[0677] Hardware

[0678] server

[0679] Smartphone

[0680] Internet connection

[0681] Various sensors (inventory sensors, shipping sensors, etc.)

[0682] software

[0683] Flask (for the API)

[0684] Pandas (for data manipulation)

[0685] Matplotlib (for generating graphs)

[0686] Database management system (e.g. MySQL)

[0687] Chart generation API (e.g. Google Charts API)

[0688] Detailed process description

[0689] 1. User request input

[0690] The user inputs a request for report creation using a smartphone, which specifically includes information such as "inventory status" and "shipping progress."

[0691] 2. Request Analysis

[0692] The server analyzes the request sent by the user and identifies the required data.

[0693] 3. Acquisition and analysis of training data

[0694] The server retrieves and analyzes data about the user's past materials and preferences from a database, thereby learning the user's preferences and style.

[0695] 4. Planning the data generation plan

[0696] Based on the learning results and requirements, plan the format in which the report will be prepared.

[0697] 5. Obtaining the necessary data

[0698] Get real-time inventory and shipping progress data from a database or API.

[0699] 6. Data analysis and graph generation

[0700] The acquired data is analyzed and charts (e.g., bar graphs, Pareto charts) are generated to show inventory status and shipping progress.

[0701] 7. Editing and formatting materials

[0702] The generated charts and graphs are formatted based on the report template, and the design is adjusted as necessary.

[0703] 8. Material Retention and Notification

[0704] The completed report is saved on an internet drive and the link is sent to the user.

[0705] 9. Get feedback and improve

[0706] It receives feedback from users, updates the learning data based on that feedback, and reflects it in subsequent report creation.

[0707] Specific examples

[0708] For example, if a logistics center manager wants to create a report that includes "This month's inventory status and shipping progress," he or she can enter the following request on a smartphone:

[0709] Prompt Sentence Examples

[0710] "Please prepare a report on this month's inventory status and shipping progress. Specifically, please include a bar graph of inventory and a Pareto chart of shipping status."

[0711] The server analyzes these requests, obtains the necessary information in real time, automatically generates a report, and notifies the manager. This system enables logistics center managers to efficiently create reports and quickly grasp the operational status.

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

[0713] Step 1: User enters a request for material creation

[0714] A user uses a smartphone to input a request to create a report. The request includes specific information (e.g., "This month's inventory status and shipping progress") and the desired type of chart (e.g., "Bar graph of inventory and Pareto chart of shipping status"). This input is sent from the device to the server.

[0715] Input: User request (e.g., "This month's inventory status and shipping progress")

[0716] Output: Request data containing the request content

[0717] Step 2: Parse the incoming request

[0718] The server receives the request sent by the user and begins analyzing it. During analysis, the request is identified and classified (e.g., "Stock status" or "Shipping progress"). At this stage, it is determined what data is required.

[0719] Input: Request data containing the requested content

[0720] Output: Analysis results (identification of required data)

[0721] Step 3: Obtain and analyze user learning data

[0722] The server retrieves data on past materials and user preferences from a database, and then uses natural language processing algorithms to analyze user preferences for design and formatting.

[0723] Input: Past data, user preference data

[0724] Output: Analysis of user preferences and styles

[0725] Step 4: Create a material generation plan

[0726] The server creates a report generation plan based on the analysis results and learning data, including the types and formats of charts and graphs to be used, and their display order.

[0727] Input: Analysis results, analysis of user preferences and style

[0728] Output: Report generation plan

[0729] Step 5: Get the data you need

[0730] The server retrieves the necessary inventory data and shipping progress data in real time from a database or external API based on the analysis results.

[0731] Input: Analysis results

[0732] Output: Inventory data, shipping progress data

[0733] Step 6: Analyze data and generate graphs

[0734] The server analyzes the acquired data and generates charts in the specified format (e.g., inventory bar graph, shipment Pareto chart). It uses Pandas to preprocess the data and Matplotlib to generate the charts.

[0735] Input: Inventory data, shipping progress data

[0736] Output: The generated diagram

[0737] Step 7: Edit and format your materials

[0738] The server includes the generated charts in a report, formats them based on a template, and makes any necessary design adjustments (color and font consistency).

[0739] Input: Generated charts, report generation plans

[0740] Output: A formatted report

[0741] Step 8: Save the material and notify users

[0742] The server stores the completed report and sends a link to the user via a smartphone application.

[0743] Input: Formatted report

[0744] Output: Saved report, notification link

[0745] Step 9: Get user feedback and update the training data

[0746] The user reviews the report and provides feedback, which the server receives and updates the learning data to reflect in future report generation.

[0747] Input: User feedback

[0748] Output: Updated training data, reflected in next data generation

[0749] The above are the specific processing steps and their contents. This system enables the logistics center manager to efficiently create high-quality reports and quickly grasp the operational status.

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

[0751] The system of the present invention allows users to input their document creation requirements, automatically generates appropriate figures and tables based on those requirements, and provides the final document. The system learns from the user's past documents and preferences, and uses this information to create an optimal plan for document generation. It then uses a diagram generation API to automatically generate diagrams as needed. The final document is saved and notified to the user. Furthermore, the system incorporates user feedback to continuously improve the system.

[0752] One of the features of this invention is the function of optimizing the document creation process according to the user's emotional state by combining it with an emotion engine that recognizes the user's emotions. Below, the program processing of this system is explained in natural language.

[0753] System Overview

[0754] The system receives the user's document creation request, analyzes it, learns from it, plans it, and then formats and edits the automatically generated figures and tables to provide the final document. In addition, it uses an emotion engine to recognize the user's emotional state and reflects the results in the design and content of the document.

[0755] Detailed program processing

[0756] 1. User request input

[0757] The user inputs a document creation request from a terminal. The request includes the document title, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The terminal then sends the request to the server.

[0758] 2. Request Analysis

[0759] The server parses the received request, identifying and categorizing the request content (e.g., identifying title, schedule progress, budget utilization, risk assessment, etc.), and stores the results of the analysis in an internal data structure.

[0760] 3. Acquiring and analyzing user learning data

[0761] The server retrieves data about the user's past materials and preferences from a database, including previously created reports and presentations, and the user's design preferences.

[0762] 4. Emotion recognition

[0763] The server utilizes an emotion engine to recognize the emotion of the user when inputting a request. The emotion engine analyzes the user's input and interactions and estimates their emotional state.

[0764] 5. Integrating learning outcomes and emotions

[0765] The server combines the acquired data with the results of emotion recognition and creates a plan for generating materials, taking into account the user's preferences and current emotional state. This plan details which charts to use and what content to include.

[0766] 6. Automatic generation of charts and graphs

[0767] The server sends a request to the chart generation API to generate the appropriate chart based on the plan, and the chart generation API generates charts and tables according to the request and returns them to the server.

[0768] 7. Editing and formatting materials

[0769] The server places the generated figures and tables into a document template, adjusting the design and layout as needed based on the user's preferences and emotional state. For example, if the user is feeling stressed, it will select a simple, easy-to-read layout.

[0770] 8. Material Retention and Notification

[0771] The server converts the completed materials into a document format (e.g. PDF, PPTX), and once the materials have been formatted and edited, they are stored in the database.

[0772] 9. Notification

[0773] The server notifies the user that the document is complete, including a link to the document and its file name.

[0774] 10. Processing feedback and updating learnings

[0775] The user can check the generated materials on the terminal and enter feedback if necessary, including suggestions for corrections and improvements.

[0776] The server receives user feedback, analyzes it, and updates the learning data based on the feedback and emotion engine data, which is then reflected in the next document creation.

[0777] Specific examples

[0778] For example, consider the case where user A wants to create a progress report for a new project. User A enters the following request from his terminal:

[0779] Title: "Project A Progress Report"

[0780] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[0781] Preferred table or graph: "Gantt chart", "pie chart"

[0782] Furthermore, the emotion engine recognizes that User A is nervous. The server integrates this emotion data with past document data to create an optimal plan. It then automatically generates appropriate diagrams using a diagram generation API. The final report is formatted and edited in a format that suits User A's preferences and current emotional state, and is notified to User A once it is complete. User A can provide feedback after checking the report, which further improves the system.

[0783] In this way, the system of the present invention can efficiently create high-quality materials that meet the user's needs and emotional state.

[0784] The processing flow will be explained below.

[0785] The system of the present invention allows users to input their document creation requirements, automatically generates appropriate figures and tables based on those requirements, and provides the final document. The system learns from the user's past documents and preferences, and uses this information to create an optimal plan for document generation. It then uses a diagram generation API to automatically generate diagrams as needed. The final document is saved and notified to the user. Furthermore, the system incorporates user feedback to continuously improve the system.

[0786] One of the features of this invention is the function of optimizing the document creation process according to the user's emotional state by combining it with an emotion engine that recognizes the user's emotions. Below, the program processing of this system is explained in natural language.

[0787] Step 1:

[0788] The user inputs a document creation request from a terminal. The request includes the document title, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The terminal then sends the input request to the server.

[0789] Step 2:

[0790] The server parses the received request, identifying and categorizing the request content (e.g., identifying title, schedule progress, budget utilization, risk assessment, etc.), and stores the results of the analysis in an internal data structure.

[0791] Step 3:

[0792] The server retrieves data about the user's past materials and preferences from a database, including previously created reports and presentations, and the user's design preferences.

[0793] Step 4:

[0794] The server uses the acquired data to run natural language processing algorithms to analyze user preferences and style, learning specific color tones, fonts, layout patterns, etc.

[0795] Step 5:

[0796] The server utilizes an emotion engine to recognize the emotion of the user when inputting a request. The emotion engine analyzes the user's input and interactions, and estimates and classifies their emotional state (e.g., stress, joy, excitement, etc.).

[0797] Step 6:

[0798] The server combines the acquired data with the results of emotion recognition and creates a plan for generating materials, taking into account the user's preferences and current emotional state. This plan details which charts to use and what content to include.

[0799] Step 7:

[0800] The server sends a request to the chart generation API, which generates the appropriate charts based on the plan. The chart generation API generates charts and tables according to the request and returns them to the server.

[0801] Step 8:

[0802] The server places the generated figures and tables into a document template, adjusting the design and layout based on the user's preferences and emotional state. For example, if the user is feeling stressed, a simple, easy-to-read layout and a calm color scheme are selected.

[0803] Step 9:

[0804] The server converts the material into a document format (e.g. PDF, PPTX), and once formatting and editing are complete, it stores the resulting material in a database.

[0805] Step 10:

[0806] The server notifies the user that the document is complete, including a link to the document and its file name.

[0807] Step 11:

[0808] The user can check the generated materials on the terminal and enter feedback if necessary, including suggestions for corrections and improvements.

[0809] Step 12:

[0810] The server receives user feedback, analyzes it, and updates the learning data based on the feedback and emotion engine data, which is then reflected in the next document creation.

[0811] As a concrete example, let us consider the case where User A is creating a progress report for a new project. User A inputs the following requests from the terminal: "Project A Progress Report", "Schedule Progress", "Budget Usage", "Risk Assessment", "Gantt Chart" and "Pie Chart". The emotion engine recognizes that User A is nervous.

[0812] The server integrates this emotional data with past document data to create an optimal plan. It then automatically generates the necessary diagrams using a diagram generation API. The final report is formatted and edited in a format that matches User A's preferences and current emotional state. Once completed, User A is notified, and User A can provide feedback after reviewing the report, which further improves the system. In this way, the system of the present invention can efficiently create high-quality documents that meet the user's requests and emotional state.

[0813] Example 2

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

[0815] In today's business environment, efficient and high-quality document creation is essential. However, conventional document creation processes require a great deal of time and effort, making it difficult to create documents that reflect the user's preferences and emotional state. Meanwhile, there is a problem in that methods for automatically generating appropriate figures and tables and providing them in an optimal format to the user are not functioning effectively. The present invention aims to provide a system that automatically generates efficient, personalized documents that take into account the user's preferences and emotional state.

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

[0817] In this invention, the server includes means for a user to input a request for creating a document, means for analyzing the input request, means for learning based on the user's past documents and preferences, means for planning document creation based on the learning results, means for automatically generating appropriate figures and tables, means for formatting and editing the generated figures and tables, means for saving the generated documents and notifying the user, means for receiving user feedback and updating the learning data, and means for recognizing the user's emotional state and optimizing the document creation process based on the emotion. This enables efficient creation of high-quality documents according to the user's request and emotional state.

[0818] The "means for users to input requests for creating materials" refers to an interface that allows users to input requests to the system via a terminal by specifying the title of the material, the information to be included, the type of charts and diagrams desired, etc.

[0819] The "means for analyzing input requests" refers to a processing function that analyzes the document creation request received by the server from the user and identifies and classifies the title, included information, type of chart, etc.

[0820] "Means for learning based on the user's past data and preferences" refers to a function in which the server retrieves the user's past data and preference data from a database, analyzes it, and learns the user's patterns and preferences.

[0821] The "means for planning material generation based on learning results" is a function that combines acquired learning data with information on emotional state to formulate an optimal material generation plan.

[0822] The "means for automatically generating appropriate charts and tables" is a function in which the server uses a chart generation API to automatically create appropriate charts and tables based on the user's requests and plans.

[0823] "Means for formatting and editing the generated figures and tables" refers to a function in which the server places the generated figures and tables in a document template and adjusts the layout and design to suit the user's preferences and emotional state.

[0824] The "means for saving the generated materials and notifying the user" is a function for converting the completed materials into a specified document format, saving them in a database, and sending a notification to inform the user.

[0825] The "means for receiving user feedback and updating learning data" is a function that analyzes the feedback provided by the user regarding the generated materials, updates the learning data based on that feedback, and reflects it in the next material creation.

[0826] "Means for recognizing the user's emotional state and optimizing the document creation process based on that emotion" is a function that uses an emotion engine to recognize the user's emotional state and reflects that information in the document creation process to optimize it.

[0827] "Figure Generation API" is an application program interface for generating figures and tables used in materials.

[0828] The system of the present invention is an information processing system in which a user inputs a request for creating a document, and appropriate figures and tables are automatically generated based on the request, and the final document is provided. A description will now be given of an embodiment of the present invention.

[0829] First, a user inputs a request for document creation using a terminal. This request includes the title of the document, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The input information is sent from the terminal to the server.

[0830] The server analyzes the received request. Specifically, it identifies the request content and classifies and extracts information such as the title and schedule progress. The results of this analysis are stored in an internal data structure.

[0831] The server then retrieves data about the user's past documents and preferences from a database, including past reports and presentations, the user's design preferences, etc. The server analyzes this data to learn the user's patterns and preferences.

[0832] The server also uses an emotion engine to recognize the user's emotional state. The emotion engine estimates the user's emotional state based on the user's input and interactions and provides the results to the server. For example, it can recognize the user's level of tension when inputting information.

[0833] By integrating the acquired training data and the emotion recognition results, the server creates an optimal plan for generating materials, which details which charts to use and what content to include.

[0834] The server then sends a request to the chart generation API to generate the appropriate charts and tables based on the plan. The chart generation API generates the charts and tables according to the request and sends the results back to the server.

[0835] The server then places the generated diagrams into a document template, adjusting the design and layout as needed based on the user's preferences and emotional state. For example, if the user is feeling stressed, a simple, easy-to-read layout is selected.

[0836] The completed document is converted into a document format (e.g., PDF, PPTX) by the server and saved in the database. The server then notifies the user that the document is complete. The notification includes the document link and file name.

[0837] The user checks the completed document and provides feedback as needed. The server receives the feedback, analyzes the content, and updates the learning data, which is then reflected in the next document creation.

[0838] As a concrete example, consider the case where user A wants to create a progress report for a new project. User A enters the following request into the terminal:

[0839] Title: "Project A Progress Report"

[0840] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[0841] Preferred table or graph: "Gantt chart", "pie chart"

[0842] Furthermore, the emotion engine recognizes that User A is nervous. The server integrates this emotion data with past document data to create an optimal plan. It then automatically generates an appropriate diagram using a diagram generation API. The final report is formatted and edited in a format that suits User A's preferences and current emotional state, and is notified to User A once it is complete. User A can provide feedback after reviewing the report, further improving the system.

[0843] In this way, the system of the present invention can efficiently create high-quality materials that meet the user's needs and emotional state.

[0844] Example prompt sentence:

[0845] Create a progress report for Project A. Include information on schedule progress, budget utilization, and risk assessment. Gantt charts and pie charts are preferred for tables and graphs. Also, consider the user's emotional state and adjust the layout to be simple and easy to read.

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

[0847] Step 1:

[0848] User request input

[0849] Specific operation: The user inputs a request for creating a document from the terminal.

[0850] Input: Title, information to include (e.g., schedule progress, budget usage, risk assessment), desired chart type (e.g., Gantt chart, pie chart).

[0851] Output: The request data sent from the device to the server.

[0852] Data processing / data calculation: The terminal collects user input and sends it to the server as structured request data.

[0853] Step 2:

[0854] Parsing the request

[0855] Specific operation: The server analyzes the received request.

[0856] Input: The request data received in step 1.

[0857] Output: An internal data structure containing the analysis results.

[0858] Data processing / data calculation: The server identifies the requested content and classifies and extracts the title and each information item.

[0859] Step 3:

[0860] Acquiring and analyzing user learning data

[0861] What it does: The server retrieves data about the user's past records and preferences from a database.

[0862] Input: User ID or historical material identification.

[0863] Output: Analysis of user's historical data and preferences.

[0864] Data processing / data calculation: The server retrieves the user's past material information from the database and analyzes the data to learn patterns and preferences.

[0865] Step 4:

[0866] emotion recognition

[0867] Specific operation: The server uses the emotion engine to recognize the emotion when the user inputs a request.

[0868] Input: User input and interaction data.

[0869] Output: Data indicating the user's emotional state.

[0870] Data processing / data calculation: The emotion engine analyzes input data and estimates the emotional state.

[0871] Step 5:

[0872] Integrating learning outcomes and emotions

[0873] Specific operation: The server integrates the acquired training data with the emotion recognition results.

[0874] Input: User preference analysis results and emotional state data.

[0875] Output: Planning data for material generation.

[0876] Data processing / data calculation: The server formulates an optimal plan for generating materials, taking into account the user's preferences and emotional state.

[0877] Step 6:

[0878] Automatic chart generation

[0879] Specific operation: The server sends a request to the chart generation API to generate the appropriate chart.

[0880] Input: Planning data for material generation.

[0881] Output: The generated chart data.

[0882] Data processing / data calculation: The chart generation API generates appropriate charts and tables based on the request and returns the data to the server.

[0883] Step 7:

[0884] Editing and formatting materials

[0885] Specific operation: The server places the generated figures and tables into the document template and adjusts the design and layout.

[0886] Input: Generated diagram data and user preference and emotional state data.

[0887] Output: Formatted and edited data.

[0888] Data processing / data calculation: The server places figures and tables on the template and adjusts the layout and design as needed.

[0889] Step 8:

[0890] Material Retention and Notification

[0891] Specific operation: The server converts the completed materials into a document format and stores them in the database.

[0892] Input: Formatted and edited data.

[0893] Output: Document data in document format (e.g. PDF, PPTX) and notification of completion of saving.

[0894] Data processing / data calculation: The server converts the material data into the specified document format and stores it in the database.

[0895] Step 9:

[0896] notification

[0897] Specific operation: The server notifies the user that the document is complete.

[0898] Input: Saved material data.

[0899] Output: A notification message to the user.

[0900] Data processing / data calculation: The server generates a notification message and sends it to the user, including the link and file name of the material.

[0901] Step 10:

[0902] Processing feedback and updating learnings

[0903] Specific operation: The user reviews the generated materials and provides feedback. The server receives the feedback, analyzes it, and updates the learning data.

[0904] Input: User feedback data.

[0905] Output: Updated training data.

[0906] Data processing / data calculation: The server analyzes the feedback, reflects the content in the learning data, and applies it to the next document creation.

[0907] (Application example 2)

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

[0909] In modern factories, many robots are in operation, and managing them requires a great deal of time and effort. Furthermore, the emotions and stress levels of managers often affect the quality of their work. A method is needed to solve these problems and generate efficient, user-friendly robot management reports.

[0910] 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 a user to input a request for document creation; means for analyzing the input request; means for learning based on the user's past documents and preferences; means for planning document creation based on the learning results; means for automatically generating appropriate figures and tables; means for formatting and editing the generated figures and tables; means for saving the generated documents and notifying the user; means for receiving user feedback and updating the learning data; and means for including an emotion recognition engine that recognizes the user's emotional state and adjusting the design and content of the documents according to the emotional state. This enables efficient and high-quality robot management reports to be generated while taking into account the emotional state of the manager.

[0911] The "means for the user to input a request for material creation" refers to an interface through which the user inputs specific requests for material creation using his / her own terminal.

[0912] The "means for analyzing an input request" refers to a software module that analyzes a request input by a user and identifies and classifies the request content.

[0913] "Means for learning based on the user's past materials and preferences" refers to an algorithm that acquires the user's past material data and preference patterns stored in a database and learns from them using a machine learning model.

[0914] "Means for planning the generation of materials based on learning results" refers to a planning module that plans what information to include in the materials and in what format based on learning results.

[0915] "Means for automatically generating appropriate figures and tables" refers to a function that uses a chart generation API based on a plan to automatically generate appropriate figures and tables.

[0916] "Means for formatting and editing the generated figures and tables" refers to software tools that are used to format the generated figures and tables to fit the design and layout of the document and make any necessary edits.

[0917] "Means for saving the generated materials and notifying the user" refers to a communication module that saves the completed materials in a database and notifies the user of the link and file name.

[0918] The "means for receiving user feedback and updating learning data" refers to a control program that receives feedback from users, analyzes the content of the feedback, and updates the learning data.

[0919] "Means for adjusting the design and content of materials according to the emotional state, including an emotion recognition engine" refers to an engine that analyzes the user's emotions and an algorithm that optimizes the design and content of materials according to the emotional state.

[0920] This invention is a system for efficiently managing robot operation data and maintenance information in factory management, thereby reducing the stress of managers. This system is implemented through the following steps.

[0921] System Overview:

[0922] The system receives requests for document creation from users, analyzes them, learns from them, plans them, automatically generates appropriate diagrams and tables, and finally provides them as documents. During this process, it uses an emotion recognition engine to recognize the user's emotional state and optimize the document creation process.

[0923] Hardware and software:

[0924] Smartphone: Used by the user to input requests for material creation.

[0925] Head-mounted display: Used by the user to view the generated materials.

[0926] Emotion recognition engine: Software that analyzes user input and recognizes their emotional state.

[0927] Chart generation API: An API for automatically generating charts and tables based on your requests.

[0928] Databases (e.g., Firebase): Used to store and retrieve user history and preferences.

[0929] Notification Service: A service for notifying users of the link and file name of the completed document.

[0930] Examples:

[0931] When a user wants to create a new robot operation report, they use their smartphone to enter the following request:

[0932] Title: "Robot Operation Report"

[0933] Information included: "Operating time", "Failure rate", "Maintenance history"

[0934] Desired table or graph: "Bar chart", "Pie chart"

[0935] The server analyzes this request and learns from the user's past materials and preferences. It also uses an emotion recognition engine to recognize the user's emotional state (e.g., tension or stress). It then creates a material generation plan that takes into account the learning results and the user's emotional state. Based on this plan, it automatically generates appropriate diagrams and tables using a diagram generation API.

[0936] The generated diagrams and tables are formatted and edited in a design optimized for the user's emotional state and saved as the final document in the database. Once the document is complete, a notification is sent to the user via a notification service. The system is continuously improved as users review the document and provide feedback.

[0937] Example prompt sentence:

[0938] "We understand that users are nervous. Please generate a simple, easy-to-read 'Robot Operation Report' for them. The report should include bar charts and pie charts with uptime, failure rate, and maintenance history."

[0939] In this way, the system can take into account the emotional state of the manager and automatically generate efficient and high-quality robot management reports, thereby reducing the burden of work.

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

[0941] Step 1:

[0942] The user inputs a request for document creation. Using a terminal, the user inputs the document title, the information to be included, the desired type of chart, etc. This input data is sent to the server. The input data includes "robot operation report," "operation time," "failure rate," "maintenance history," "bar chart," "pie chart," etc.

[0943] Step 2:

[0944] The server analyzes the input request. The server analyzes the received request data and identifies the document title, the information to be included, the desired type of chart, etc. The analysis results are stored in an internal data structure. For example, the server identifies "Robot Operation Report" as the title and classifies "Operation Hours," "Failure Rate," and "Maintenance History" as the required information.

[0945] Step 3:

[0946] The server learns based on the user's past data and preferences. The server retrieves the user's past data and design preferences from a database. This data is input into a machine learning algorithm to learn the user's preferences and trends. For example, it analyzes past robot reports and design patterns.

[0947] Step 4:

[0948] The server creates a plan for generating materials based on the learning results. Based on the acquired data and the learned user preferences, it plans what information to include in the materials and in what format. This plan may include, for example, using a bar chart for "operating time" and a pie chart for "failure rate."

[0949] Step 5:

[0950] The server uses an emotion recognition engine to recognize the user's emotional state. It analyzes the user's typing speed and click patterns to estimate their emotional state, such as tension or stress. The results are used to adjust the design and content of the materials.

[0951] Step 6:

[0952] The server automatically generates the appropriate charts and tables. Based on the plan, it sends a request to the chart generation API to generate the necessary charts (bar charts and pie charts). For example, it generates a bar chart using the "uptime" data and a pie chart using the "failure rate" data.

[0953] Step 7:

[0954] The server formats and edits the generated diagrams and tables. It places the generated diagrams and tables into a document template and adjusts the design and layout based on the user's emotional state. For example, if the user is nervous, it will create a simple, easy-to-read layout.

[0955] Step 8:

[0956] The server saves the generated document and notifies the user. The server saves the final document in PDF or PPTX format and notifies the user of the link and file name. The notification includes a download link for the generated document.

[0957] Step 9:

[0958] The user provides feedback. Through the terminal, the user inputs feedback on the generated materials. The feedback includes corrections and improvements.

[0959] Step 10:

[0960] The server analyzes user feedback and updates the learning data. The provided feedback is analyzed and reflected in the next data generation along with the emotion engine data. This allows the system to continuously improve.

[0961] This series of steps enables efficient and high-quality robot management reports to be automatically generated while taking into consideration the user's emotional state.

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

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

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

[0965] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0978] The system of the present invention allows users to input their requirements for creating materials, automatically generates appropriate figures and tables based on those requirements, and provides the final materials. The program processing of this system is explained below in natural language, and specific examples are also provided.

[0979] System Overview

[0980] The system begins with the user inputting their document requirements, analyzes those requirements, and automatically generates high-quality documents based on the user's preferences. The server learns from the user's past documents and preferences, and based on that, creates an optimal plan for document generation, automatically generating appropriate figures and tables using a diagram generation API. The final document is saved and notified to the user. The system also incorporates user feedback to continuously improve it.

[0981] Detailed program processing

[0982] 1. User request input

[0983] Users use a terminal to input a document creation request, which includes the document title, the information to be included (e.g., schedule progress, budget utilization, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart).

[0984] The terminal transmits the request entered by the user to the server.

[0985] 2. Request Analysis

[0986] The server analyzes the received request, which involves identifying and classifying the request content (e.g., identifying the title, schedule progress, budget utilization, risk assessment, etc.).

[0987] The analysis results are stored in an internal data structure.

[0988] 3. Acquiring and analyzing user learning data

[0989] The server retrieves data about the user's past records and preferences from a database.

[0990] Using this data, natural language processing algorithms analyze user preferences and style, learning, for example, specific color tones, fonts, and layout patterns.

[0991] 4. Planning the data generation plan

[0992] Based on the learning results and the analyzed requirements, the server creates a plan for generating materials, detailing which charts to use and what content to include.

[0993] 5. Automatic generation of charts and graphs

[0994] The server sends a request to the chart generation API to generate the appropriate chart (e.g., Gantt chart, pie chart, quantitative table) based on the plan.

[0995] The chart generation API generates charts and tables according to the request and returns them to the server.

[0996] 6. Editing and formatting materials

[0997] The server places the generated figures and tables into a document template.

[0998] Based on the user's preferences, the design and layout are adjusted as necessary, for example, adjusting the order of figures and tables, color consistency, font style, etc.

[0999] The completed materials are converted into a document format (e.g. PDF, PPTX).

[1000] 7. Material Retention and Notification

[1001] The server stores the completed documents in a database.

[1002] The user is notified that the document is complete, including a link to the document and the file name.

[1003] 8. Processing feedback and updating learnings

[1004] The user uses the terminal to check the generated materials and input feedback if necessary.

[1005] The feedback provided by the user is sent to the server and analyzed.

[1006] The server updates the learning data based on the feedback and reflects it in the next document creation.

[1007] Specific examples

[1008] For example, consider the case where user A wants to create a progress report for a new project. User A enters the following request from his terminal:

[1009] Title: "Project A Progress Report"

[1010] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[1011] Preferred table or graph: "Gantt chart", "pie chart"

[1012] The server receives this request, learns from past documents and preferences, and creates a plan. It then automatically generates the necessary diagrams using a diagram generation API. The final report is formatted and edited in a format that suits User A's preferences, and User A is notified once it is complete. User A can review the completed document and provide feedback, which will be used to continuously improve the system.

[1013] In this way, the system of the present invention can efficiently create high-quality materials that meet the user's requirements.

[1014] The processing flow will be explained below.

[1015] Step 1:

[1016] The user inputs a document creation request from a terminal. The request includes the document title, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The terminal then sends the input request to the server.

[1017] Step 2:

[1018] The server parses the received request, identifying and categorizing the request content (e.g., identifying title, schedule progress, budget utilization, risk assessment, etc.), and stores the results of the analysis in an internal data structure.

[1019] Step 3:

[1020] The server retrieves data about the user's past materials and preferences from a database, including previously created reports and presentations, and the user's design preferences.

[1021] Step 4:

[1022] The server uses the acquired data to run natural language processing algorithms to analyze user preferences and style, learning specific color tones, fonts, layout patterns, etc.

[1023] Step 5:

[1024] Based on the learning results and the analyzed requirements, the server creates a plan for generating materials, detailing which charts to use and what content to include.

[1025] Step 6:

[1026] The server sends a request to the chart generation API to generate the appropriate chart (e.g., Gantt chart, pie chart, quantitative table) based on the plan. The chart generation API generates the chart or table according to the request and returns it to the server.

[1027] Step 7:

[1028] The server places the generated figures and tables into a document template, and adjusts the design and layout as needed based on the user's preferences, such as adjusting the order of figures and tables, color consistency, font style, etc.

[1029] Step 8:

[1030] The server converts the completed materials into a document format (e.g. PDF, PPTX), and once the materials have been formatted and edited, they are stored in the database.

[1031] Step 9:

[1032] The server notifies the user that the document is complete, including a link to the document and its file name.

[1033] Step 10:

[1034] The user can check the generated materials on the terminal and enter feedback if necessary, including suggestions for corrections and improvements.

[1035] Step 11:

[1036] The server receives and analyzes the user's feedback, updates the learning data based on the feedback, and reflects it in the next document creation.

[1037] Example 1

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

[1039] The conventional document creation process required a lot of time and effort, making it difficult to create efficient, high-quality documents quickly. Furthermore, it was difficult to automatically generate documents tailored to individual user preferences, creating a need for improved user satisfaction.

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

[1041] In this invention, the server includes means for inputting user requests, means for analyzing the requests, means for learning based on the user's past materials and preferences, means for planning material generation based on the learning results, means for automatically generating appropriate figures and tables, means for formatting and editing the generated figures and tables, means for saving the generated materials and notifying the user, means for receiving user feedback and updating the learning data, means for analyzing input from the terminal and creating a plan on the server, means for using a diagram generation API for automatically generating specific diagrams and tables, and means for arranging the automatically generated materials in a template and adjusting the design based on the user's preferences. This enables efficient and high-quality material creation and enables materials tailored to the preferences of individual users to be quickly provided.

[1042] A "user" is an entity that uses the system to input a request for material creation.

[1043] The "means for inputting requests" refers to a method or device that allows a user to provide the system with the information or requests required for creating materials.

[1044] "Means for analyzing requirements" is the process of breaking down input requirements, classifying them into specific categories, and understanding them.

[1045] "Means for learning based on the user's past materials and preferences" refers to a method for analyzing past materials and the user's usage history to understand the user's preferences and style.

[1046] "Means for planning material generation" is the process of creating a plan for how to compose materials based on the analyzed requirements and learning results.

[1047] "Means for automatically generating appropriate figures and tables" refers to a method for automatically creating figures and tables to be included in the materials.

[1048] A "diagram generation API" is a program interface that uses external services or software to generate diagrams in a specified format.

[1049] "Means for formatting and editing generated figures and tables" refers to methods for formatting automatically generated figures and tables, and is the process of adjusting the design and layout to suit the user's preferences.

[1050] The "means for storing the generated materials and notifying the user" refers to a method for safely storing the generated materials and notifying the user when the materials are completed.

[1051] "Means for receiving user feedback and updating learning data" refers to the process of collecting opinions and suggestions for improvement from users and improving the system's learning data based on them.

[1052] "Means for analyzing input from a terminal and creating a plan at a server" refers to a method in which a server receives a request input by a user through a terminal, analyzes it, and creates a plan for generating materials.

[1053] "Means for placing automatically generated materials in a template and adjusting the design based on the user's preferences" refers to the process of fitting the generated materials into a specified format and, if necessary, making design modifications to suit the user's preferences.

[1054] The system of the present invention starts when a user requests the creation of a document. The specific processing flow and operation of the system will be explained below.

[1055] A user uses a terminal to input a request for the creation of a document. The request includes the title of the document, the information to be included, the type of chart desired, etc. For example, when creating a project progress report, the user inputs the title "Project A Progress Report," information such as "Schedule Progress," "Budget Usage Status," and "Risk Assessment," as well as a request for charts such as a "Gantt Chart" or "Pie Chart."

[1056] The terminal sends the user's input to the server. The server analyzes the received request, breaks it down into a specific data structure, and stores it. Through the analysis, the request content (e.g., document title, schedule progress, budget usage, risk assessment, etc.) becomes clear.

[1057] The server then retrieves data about the user's past materials and preferences from a database and uses natural language processing algorithms to analyze the user's preferences and style, for example learning the font styles and color palettes the user has used in the past.

[1058] The server creates a plan for generating materials based on the learning results. This plan includes specific details such as which diagrams to place where and what content they should contain. After the plan is created, the server sends a request to the diagram generation API to generate the necessary diagrams (e.g., Gantt charts, pie charts).

[1059] The diagram generation API generates diagrams in the specified format in response to a request and returns the results to the server, which places the generated diagrams in a document template and adjusts the design and layout as needed based on the user's preferences, such as adjusting the diagram order, color matching, and font style.

[1060] The final document is converted into the specified document format (e.g., PDF, PPTX) and saved in the database by the server. The server notifies the user that the document is complete, and the notification includes a link to the document and its file name.

[1061] If the user wants to review the generated materials and provide feedback, they can enter it on their device. The feedback is sent to the server, which analyzes it and updates the system's learning data. This allows the feedback to be reflected the next time materials are created, allowing the system to continuously improve.

[1062] Examples of concrete examples and prompts

[1063] For example, consider a situation where user A wants to create a progress report for a new project. User A enters the following request into his terminal:

[1064] Title: "Project A Progress Report"

[1065] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[1066] Preferred table or graph: "Gantt chart", "pie chart"

[1067] Based on this request, the server generates the materials and provides the final report to User A. An example of a prompt sentence to input to the generative AI model is as follows:

[1068] I'd like to create a progress report for a new project. Please include the following required information:

[1069] Title: "Project A Progress Report"

[1070] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[1071] Preferred table or graph: "Gantt chart", "pie chart"

[1072] In this way, this system can efficiently create high-quality materials that meet the user's requirements.

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

[1074] Step 1:

[1075] The user inputs a request for material creation.

[1076] The user uses a terminal to input the title of the document, the information to be included, and the type of chart or diagram desired. For example, the user inputs the title "Project A Progress Report," the information to be included is "Schedule Progress," "Budget Usage Status," and "Risk Assessment," and the chart or diagram desired is "Gantt Chart" or "Pie Chart."

[1077] Input: Title of the document, information to include, desired type of chart

[1078] Output: User request data

[1079] Step 2:

[1080] The terminal sends the user's request to the server.

[1081] The terminal transmits the input request data to the server, which then receives the user's request for creating a document.

[1082] Input: User request data

[1083] Output: Sending the request data to the server

[1084] Step 3:

[1085] The server analyzes the request received from the user.

[1086] The server analyzes the request data, breaks down the request content into specific data structures, and stores them. For example, it identifies elements such as "title," "schedule progress," "budget usage," and "risk assessment."

[1087] Input: Request data

[1088] Output: Parsed request data

[1089] Step 4:

[1090] The server retrieves data about the user's past records and preferences from a database.

[1091] The server retrieves the user's past and preference data from a database and uses natural language processing algorithms to analyze the user's preferences and style, for example, learning specific font styles and color palettes.

[1092] Input: Parsed request data

[1093] Output: User's training data

[1094] Step 5:

[1095] The server creates a plan for generating materials based on the learning results.

[1096] The server creates a plan for generating materials based on the analyzed requests and learning results, including details such as which information to place in which charts.

[1097] Input: User training data

[1098] Output: Data generation plan

[1099] Step 6:

[1100] The server sends a request to the diagram generation API, requesting that a diagram be automatically generated based on the plan.

[1101] The server sends a request to the chart generation API, instructing it to generate charts such as Gantt charts, pie charts, etc. The chart generation API generates charts and tables according to the request and returns the results to the server.

[1102] Input: Data Generation Plan

[1103] Output: Generated chart data

[1104] Step 7:

[1105] The server places the generated diagrams and tables into a document template and adjusts the design and layout as needed.

[1106] The server places the generated diagrams into a document template and adjusts the design and layout based on the user's preferences, such as adjusting the diagram order, color consistency, and font style.

[1107] Input: Generated chart data

[1108] Output: Formatted and edited data

[1109] Step 8:

[1110] The server converts the completed materials into a document format and stores them in a database.

[1111] The server converts the formatted and edited data into PDF or PPTX format, stores it in the database, and notifies the user that the data is complete. The notification includes a link to the data and the file name.

[1112] Input: Formatted and edited data

[1113] Output: Documentation, user notifications

[1114] Step 9:

[1115] The user reviews the generated material and provides feedback.

[1116] The user can use the device to check the generated data and enter feedback as needed. For example, they can enter feedback such as "I would like the colors of the Gantt chart to be a little brighter." The feedback is sent from the device to the server.

[1117] Input: Generated materials, user feedback

[1118] Output: Feedback data

[1119] Step 10:

[1120] The server analyzes the feedback and updates the training data.

[1121] The server analyzes the feedback data and updates the system's learning data, so that the feedback is reflected in the next document creation, allowing the system to continuously improve.

[1122] Input: Feedback data

[1123] Output: Updated training data

[1124] The above are the specific operations and steps in the processing flow of the program of this system.

[1125] (Application example 1)

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

[1127] At logistics centers, managers need to accurately and quickly grasp inventory status and shipping progress, but manually collecting data and creating documents takes time and effort. It is also difficult to create reports based on past documents or in a format that suits the manager's preferences. This hinders efficient operations.

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

[1129] In this invention, the server includes: means for a user to input a request for document creation; means for analyzing the input request; means for learning based on the user's past documents and preferences; means for planning document creation based on the learning results; means for automatically generating appropriate figures and tables; means for formatting and editing the generated figures and tables; means for saving the generated documents and notifying the user; means for receiving user feedback and updating the learning data; means for acquiring necessary data from a database or API; means for performing data analysis and generating graphs; and means for linking with a business system to acquire data in real time. This enables managers to efficiently create high-quality reports and quickly grasp the operating status of the logistics center.

[1130] The "means for a user to input a request for creating a material" is an interface that allows a logged-in user to input a request for creating a material containing specific information.

[1131] The "means for analyzing the input request" is an algorithm for analyzing the content of the request for creating a document input by the user and identifying the type of data and charts required.

[1132] The "means for learning based on the user's past materials and preferences" is a machine learning model for learning based on materials created by the user in the past and the user's preferred designs and formats.

[1133] "Means for planning the generation of materials based on learning results" is a mechanism for planning the format in which materials should be created based on the learned data.

[1134] The "means for automatically generating appropriate figures and tables" is a software module for automatically generating necessary figures and tables based on the plan.

[1135] "Means for formatting and editing the generated figures and tables" refers to tools for formatting the generated figures and tables to fit the format of the document and adjusting the design as necessary.

[1136] "Means for saving generated materials and notifying users" refers to a system for saving completed materials and notifying users of their links or files.

[1137] The "means for receiving user feedback and updating learning data" is an algorithm for receiving feedback from users and reflecting that feedback in the next document creation.

[1138] "Means for obtaining necessary data from a database or API" refers to an interface for obtaining data necessary for document creation from a database or external API.

[1139] "Means for data analysis and graph generation" refers to the process for analyzing acquired data and generating graphs and tables in the format required for the report.

[1140] "Means of linking with business systems to obtain data in real time" refers to a mechanism that links with the logistics center's business systems to obtain the necessary data in real time.

[1141] The system of the present invention can automatically generate reports to support the work of a manager at a logistics center. A specific embodiment of the system will be described below.

[1142] System Configuration

[1143] This system mainly consists of a server, a user device (smartphone), various sensors, and an API. The server receives requests from users and manages a series of processes that automatically generate reports based on those requests. The user device is used to input requests for report creation and provide feedback.

[1144] Program processing overview

[1145] Hardware and Software

[1146] Hardware

[1147] server

[1148] Smartphone

[1149] Internet connection

[1150] Various sensors (inventory sensors, shipping sensors, etc.)

[1151] software

[1152] Flask (for the API)

[1153] Pandas (for data manipulation)

[1154] Matplotlib (for generating graphs)

[1155] Database management system (e.g. MySQL)

[1156] Chart generation API (e.g. Google Charts API)

[1157] Detailed process description

[1158] 1. User request input

[1159] The user inputs a request for report creation using a smartphone, which specifically includes information such as "inventory status" and "shipping progress."

[1160] 2. Request Analysis

[1161] The server analyzes the request sent by the user and identifies the required data.

[1162] 3. Acquisition and analysis of training data

[1163] The server retrieves and analyzes data about the user's past materials and preferences from a database, thereby learning the user's preferences and style.

[1164] 4. Planning the data generation plan

[1165] Based on the learning results and requirements, plan the format in which the report will be prepared.

[1166] 5. Obtaining the necessary data

[1167] Get real-time inventory and shipping progress data from a database or API.

[1168] 6. Data analysis and graph generation

[1169] The acquired data is analyzed and charts (e.g., bar graphs, Pareto charts) are generated to show inventory status and shipping progress.

[1170] 7. Editing and formatting materials

[1171] The generated charts and graphs are formatted based on the report template, and the design is adjusted as necessary.

[1172] 8. Material Retention and Notification

[1173] The completed report is saved on an internet drive and the link is sent to the user.

[1174] 9. Get feedback and improve

[1175] It receives feedback from users, updates the learning data based on that feedback, and reflects it in subsequent report creation.

[1176] Specific examples

[1177] For example, if a logistics center manager wants to create a report that includes "This month's inventory status and shipping progress," he or she can enter the following request on a smartphone:

[1178] Prompt Sentence Examples

[1179] "Please prepare a report on this month's inventory status and shipping progress. Specifically, please include a bar graph of inventory and a Pareto chart of shipping status."

[1180] The server analyzes these requests, obtains the necessary information in real time, automatically generates a report, and notifies the manager. This system enables logistics center managers to efficiently create reports and quickly grasp the operational status.

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

[1182] Step 1: User enters a request for material creation

[1183] A user uses a smartphone to input a request to create a report. The request includes specific information (e.g., "This month's inventory status and shipping progress") and the desired type of chart (e.g., "Bar graph of inventory and Pareto chart of shipping status"). This input is sent from the device to the server.

[1184] Input: User request (e.g., "This month's inventory status and shipping progress")

[1185] Output: Request data containing the request content

[1186] Step 2: Parse the incoming request

[1187] The server receives the request sent by the user and begins analyzing it. During analysis, the request is identified and classified (e.g., "Stock status" or "Shipping progress"). At this stage, it is determined what data is required.

[1188] Input: Request data containing the requested content

[1189] Output: Analysis results (identification of required data)

[1190] Step 3: Obtain and analyze user learning data

[1191] The server retrieves data on past materials and user preferences from a database, and then uses natural language processing algorithms to analyze user preferences for design and formatting.

[1192] Input: Past data, user preference data

[1193] Output: Analysis of user preferences and styles

[1194] Step 4: Create a material generation plan

[1195] The server creates a report generation plan based on the analysis results and learning data, including the types and formats of charts and graphs to be used, and their display order.

[1196] Input: Analysis results, analysis of user preferences and style

[1197] Output: Report generation plan

[1198] Step 5: Get the data you need

[1199] The server retrieves the necessary inventory data and shipping progress data in real time from a database or external API based on the analysis results.

[1200] Input: Analysis results

[1201] Output: Inventory data, shipping progress data

[1202] Step 6: Analyze data and generate graphs

[1203] The server analyzes the acquired data and generates charts in the specified format (e.g., inventory bar graph, shipment Pareto chart). It uses Pandas to preprocess the data and Matplotlib to generate the charts.

[1204] Input: Inventory data, shipping progress data

[1205] Output: The generated diagram

[1206] Step 7: Edit and format your materials

[1207] The server includes the generated charts in a report, formats them based on a template, and makes any necessary design adjustments (color and font consistency).

[1208] Input: Generated charts, report generation plans

[1209] Output: A formatted report

[1210] Step 8: Save the material and notify users

[1211] The server stores the completed report and sends a link to the user via a smartphone application.

[1212] Input: Formatted report

[1213] Output: Saved report, notification link

[1214] Step 9: Get user feedback and update the training data

[1215] The user reviews the report and provides feedback, which the server receives and updates the learning data to reflect in future report generation.

[1216] Input: User feedback

[1217] Output: Updated training data, reflected in next data generation

[1218] The above are the specific processing steps and their contents. This system enables the logistics center manager to efficiently create high-quality reports and quickly grasp the operational status.

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

[1220] The system of the present invention allows users to input their document creation requirements, automatically generates appropriate figures and tables based on those requirements, and provides the final document. The system learns from the user's past documents and preferences, and uses this information to create an optimal plan for document generation. It then uses a diagram generation API to automatically generate diagrams as needed. The final document is saved and notified to the user. Furthermore, the system incorporates user feedback to continuously improve the system.

[1221] One of the features of this invention is the function of optimizing the document creation process according to the user's emotional state by combining it with an emotion engine that recognizes the user's emotions. Below, the program processing of this system is explained in natural language.

[1222] System Overview

[1223] The system receives the user's document creation request, analyzes it, learns from it, plans it, and then formats and edits the automatically generated figures and tables to provide the final document. In addition, it uses an emotion engine to recognize the user's emotional state and reflects the results in the design and content of the document.

[1224] Detailed program processing

[1225] 1. User request input

[1226] The user inputs a document creation request from a terminal. The request includes the document title, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The terminal then sends the request to the server.

[1227] 2. Request Analysis

[1228] The server parses the received request, identifying and categorizing the request content (e.g., identifying title, schedule progress, budget utilization, risk assessment, etc.), and stores the results of the analysis in an internal data structure.

[1229] 3. Acquiring and analyzing user learning data

[1230] The server retrieves data about the user's past materials and preferences from a database, including previously created reports and presentations, and the user's design preferences.

[1231] 4. Emotion recognition

[1232] The server utilizes an emotion engine to recognize the emotion of the user when inputting a request. The emotion engine analyzes the user's input and interactions and estimates their emotional state.

[1233] 5. Integrating learning outcomes and emotions

[1234] The server combines the acquired data with the results of emotion recognition and creates a plan for generating materials, taking into account the user's preferences and current emotional state. This plan details which charts to use and what content to include.

[1235] 6. Automatic generation of charts and graphs

[1236] The server sends a request to the chart generation API to generate the appropriate chart based on the plan, and the chart generation API generates charts and tables according to the request and returns them to the server.

[1237] 7. Editing and formatting materials

[1238] The server places the generated figures and tables into a document template, adjusting the design and layout as needed based on the user's preferences and emotional state. For example, if the user is feeling stressed, it will select a simple, easy-to-read layout.

[1239] 8. Material Retention and Notification

[1240] The server converts the completed materials into a document format (e.g. PDF, PPTX), and once the materials have been formatted and edited, they are stored in the database.

[1241] 9. Notification

[1242] The server notifies the user that the document is complete, including a link to the document and its file name.

[1243] 10. Processing feedback and updating learnings

[1244] The user can check the generated materials on the terminal and enter feedback if necessary, including suggestions for corrections and improvements.

[1245] The server receives user feedback, analyzes it, and updates the learning data based on the feedback and emotion engine data, which is then reflected in the next document creation.

[1246] Specific examples

[1247] For example, consider the case where user A wants to create a progress report for a new project. User A enters the following request from his terminal:

[1248] Title: "Project A Progress Report"

[1249] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[1250] Preferred table or graph: "Gantt chart", "pie chart"

[1251] Furthermore, the emotion engine recognizes that User A is nervous. The server integrates this emotion data with past document data to create an optimal plan. It then automatically generates appropriate diagrams using a diagram generation API. The final report is formatted and edited in a format that suits User A's preferences and current emotional state, and is notified to User A once it is complete. User A can provide feedback after checking the report, which further improves the system.

[1252] In this way, the system of the present invention can efficiently create high-quality materials that meet the user's needs and emotional state.

[1253] The processing flow will be explained below.

[1254] The system of the present invention allows users to input their document creation requirements, automatically generates appropriate figures and tables based on those requirements, and provides the final document. The system learns from the user's past documents and preferences, and uses this information to create an optimal plan for document generation. It then uses a diagram generation API to automatically generate diagrams as needed. The final document is saved and notified to the user. Furthermore, the system incorporates user feedback to continuously improve the system.

[1255] One of the features of this invention is the function of optimizing the document creation process according to the user's emotional state by combining it with an emotion engine that recognizes the user's emotions. Below, the program processing of this system is explained in natural language.

[1256] Step 1:

[1257] The user inputs a document creation request from a terminal. The request includes the document title, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The terminal then sends the input request to the server.

[1258] Step 2:

[1259] The server parses the received request, identifying and categorizing the request content (e.g., identifying title, schedule progress, budget utilization, risk assessment, etc.), and stores the results of the analysis in an internal data structure.

[1260] Step 3:

[1261] The server retrieves data about the user's past materials and preferences from a database, including previously created reports and presentations, and the user's design preferences.

[1262] Step 4:

[1263] The server uses the acquired data to run natural language processing algorithms to analyze user preferences and style, learning specific color tones, fonts, layout patterns, etc.

[1264] Step 5:

[1265] The server utilizes an emotion engine to recognize the emotion of the user when inputting a request. The emotion engine analyzes the user's input and interactions, and estimates and classifies their emotional state (e.g., stress, joy, excitement, etc.).

[1266] Step 6:

[1267] The server combines the acquired data with the results of emotion recognition and creates a plan for generating materials, taking into account the user's preferences and current emotional state. This plan details which charts to use and what content to include.

[1268] Step 7:

[1269] The server sends a request to the chart generation API, which generates the appropriate charts based on the plan. The chart generation API generates charts and tables according to the request and returns them to the server.

[1270] Step 8:

[1271] The server places the generated figures and tables into a document template, adjusting the design and layout based on the user's preferences and emotional state. For example, if the user is feeling stressed, a simple, easy-to-read layout and a calm color scheme are selected.

[1272] Step 9:

[1273] The server converts the material into a document format (e.g. PDF, PPTX), and once formatting and editing are complete, it stores the resulting material in a database.

[1274] Step 10:

[1275] The server notifies the user that the document is complete, including a link to the document and its file name.

[1276] Step 11:

[1277] The user can check the generated materials on the terminal and enter feedback if necessary, including suggestions for corrections and improvements.

[1278] Step 12:

[1279] The server receives user feedback, analyzes it, and updates the learning data based on the feedback and emotion engine data, which is then reflected in the next document creation.

[1280] As a concrete example, let us consider the case where User A is creating a progress report for a new project. User A inputs the following requests from the terminal: "Project A Progress Report", "Schedule Progress", "Budget Usage", "Risk Assessment", "Gantt Chart" and "Pie Chart". The emotion engine recognizes that User A is nervous.

[1281] The server integrates this emotional data with past document data to create an optimal plan. It then automatically generates the necessary diagrams using a diagram generation API. The final report is formatted and edited in a format that matches User A's preferences and current emotional state. Once completed, User A is notified, and User A can provide feedback after reviewing the report, which further improves the system. In this way, the system of the present invention can efficiently create high-quality documents that meet the user's requests and emotional state.

[1282] Example 2

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

[1284] In today's business environment, efficient and high-quality document creation is essential. However, conventional document creation processes require a great deal of time and effort, making it difficult to create documents that reflect the user's preferences and emotional state. Meanwhile, there is a problem in that methods for automatically generating appropriate figures and tables and providing them in an optimal format to the user are not functioning effectively. The present invention aims to provide a system that automatically generates efficient, personalized documents that take into account the user's preferences and emotional state.

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

[1286] In this invention, the server includes means for a user to input a request for creating a document, means for analyzing the input request, means for learning based on the user's past documents and preferences, means for planning document creation based on the learning results, means for automatically generating appropriate figures and tables, means for formatting and editing the generated figures and tables, means for saving the generated documents and notifying the user, means for receiving user feedback and updating the learning data, and means for recognizing the user's emotional state and optimizing the document creation process based on the emotion. This enables efficient creation of high-quality documents according to the user's request and emotional state.

[1287] The "means for users to input requests for creating materials" refers to an interface that allows users to input requests to the system via a terminal by specifying the title of the material, the information to be included, the type of charts and diagrams desired, etc.

[1288] The "means for analyzing input requests" refers to a processing function that analyzes the document creation request received by the server from the user and identifies and classifies the title, included information, type of chart, etc.

[1289] "Means for learning based on the user's past data and preferences" refers to a function in which the server retrieves the user's past data and preference data from a database, analyzes it, and learns the user's patterns and preferences.

[1290] The "means for planning material generation based on learning results" is a function that combines acquired learning data with information on emotional state to formulate an optimal material generation plan.

[1291] The "means for automatically generating appropriate charts and tables" is a function in which the server uses a chart generation API to automatically create appropriate charts and tables based on the user's requests and plans.

[1292] "Means for formatting and editing the generated figures and tables" refers to a function in which the server places the generated figures and tables in a document template and adjusts the layout and design to suit the user's preferences and emotional state.

[1293] The "means for saving the generated materials and notifying the user" is a function for converting the completed materials into a specified document format, saving them in a database, and sending a notification to inform the user.

[1294] The "means for receiving user feedback and updating learning data" is a function that analyzes the feedback provided by the user regarding the generated materials, updates the learning data based on that feedback, and reflects it in the next material creation.

[1295] "Means for recognizing the user's emotional state and optimizing the document creation process based on that emotion" is a function that uses an emotion engine to recognize the user's emotional state and reflects that information in the document creation process to optimize it.

[1296] "Figure Generation API" is an application program interface for generating figures and tables used in materials.

[1297] The system of the present invention is an information processing system in which a user inputs a request for creating a document, and appropriate figures and tables are automatically generated based on the request, and the final document is provided. A description will now be given of an embodiment of the present invention.

[1298] First, a user inputs a request for document creation using a terminal. This request includes the title of the document, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The input information is sent from the terminal to the server.

[1299] The server analyzes the received request. Specifically, it identifies the request content and classifies and extracts information such as the title and schedule progress. The results of this analysis are stored in an internal data structure.

[1300] The server then retrieves data about the user's past documents and preferences from a database, including past reports and presentations, the user's design preferences, etc. The server analyzes this data to learn the user's patterns and preferences.

[1301] The server also uses an emotion engine to recognize the user's emotional state. The emotion engine estimates the user's emotional state based on the user's input and interactions and provides the results to the server. For example, it can recognize the user's level of tension when inputting information.

[1302] By integrating the acquired training data and the emotion recognition results, the server creates an optimal plan for generating materials, which details which charts to use and what content to include.

[1303] The server then sends a request to the chart generation API to generate the appropriate charts and tables based on the plan. The chart generation API generates the charts and tables according to the request and sends the results back to the server.

[1304] The server then places the generated diagrams into a document template, adjusting the design and layout as needed based on the user's preferences and emotional state. For example, if the user is feeling stressed, a simple, easy-to-read layout is selected.

[1305] The completed document is converted into a document format (e.g., PDF, PPTX) by the server and saved in the database. The server then notifies the user that the document is complete. The notification includes the document link and file name.

[1306] The user checks the completed document and provides feedback as needed. The server receives the feedback, analyzes the content, and updates the learning data, which is then reflected in the next document creation.

[1307] As a concrete example, consider the case where user A wants to create a progress report for a new project. User A enters the following request into the terminal:

[1308] Title: "Project A Progress Report"

[1309] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[1310] Preferred table or graph: "Gantt chart", "pie chart"

[1311] Furthermore, the emotion engine recognizes that User A is nervous. The server integrates this emotion data with past document data to create an optimal plan. It then automatically generates an appropriate diagram using a diagram generation API. The final report is formatted and edited in a format that suits User A's preferences and current emotional state, and is notified to User A once it is complete. User A can provide feedback after reviewing the report, further improving the system.

[1312] In this way, the system of the present invention can efficiently create high-quality materials that meet the user's needs and emotional state.

[1313] Example prompt sentence:

[1314] Create a progress report for Project A. Include information on schedule progress, budget utilization, and risk assessment. Gantt charts and pie charts are preferred for tables and graphs. Also, consider the user's emotional state and adjust the layout to be simple and easy to read.

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

[1316] Step 1:

[1317] User request input

[1318] Specific operation: The user inputs a request for creating a document from the terminal.

[1319] Input: Title, information to include (e.g., schedule progress, budget usage, risk assessment), desired chart type (e.g., Gantt chart, pie chart).

[1320] Output: The request data sent from the device to the server.

[1321] Data processing / data calculation: The terminal collects user input and sends it to the server as structured request data.

[1322] Step 2:

[1323] Parsing the request

[1324] Specific operation: The server analyzes the received request.

[1325] Input: The request data received in step 1.

[1326] Output: An internal data structure containing the analysis results.

[1327] Data processing / data calculation: The server identifies the requested content and classifies and extracts the title and each information item.

[1328] Step 3:

[1329] Acquiring and analyzing user learning data

[1330] What it does: The server retrieves data about the user's past records and preferences from a database.

[1331] Input: User ID or historical material identification.

[1332] Output: Analysis of user's historical data and preferences.

[1333] Data processing / data calculation: The server retrieves the user's past material information from the database and analyzes the data to learn patterns and preferences.

[1334] Step 4:

[1335] emotion recognition

[1336] Specific operation: The server uses the emotion engine to recognize the emotion when the user inputs a request.

[1337] Input: User input and interaction data.

[1338] Output: Data indicating the user's emotional state.

[1339] Data processing / data calculation: The emotion engine analyzes input data and estimates the emotional state.

[1340] Step 5:

[1341] Integrating learning outcomes and emotions

[1342] Specific operation: The server integrates the acquired training data with the emotion recognition results.

[1343] Input: User preference analysis results and emotional state data.

[1344] Output: Planning data for material generation.

[1345] Data processing / data calculation: The server formulates an optimal plan for generating materials, taking into account the user's preferences and emotional state.

[1346] Step 6:

[1347] Automatic chart generation

[1348] Specific operation: The server sends a request to the chart generation API to generate the appropriate chart.

[1349] Input: Planning data for material generation.

[1350] Output: The generated chart data.

[1351] Data processing / data calculation: The chart generation API generates appropriate charts and tables based on the request and returns the data to the server.

[1352] Step 7:

[1353] Editing and formatting materials

[1354] Specific operation: The server places the generated figures and tables into the document template and adjusts the design and layout.

[1355] Input: Generated diagram data and user preference and emotional state data.

[1356] Output: Formatted and edited data.

[1357] Data processing / data calculation: The server places figures and tables on the template and adjusts the layout and design as needed.

[1358] Step 8:

[1359] Material Retention and Notification

[1360] Specific operation: The server converts the completed materials into a document format and stores them in the database.

[1361] Input: Formatted and edited data.

[1362] Output: Document data in document format (e.g. PDF, PPTX) and notification of completion of saving.

[1363] Data processing / data calculation: The server converts the material data into the specified document format and stores it in the database.

[1364] Step 9:

[1365] notification

[1366] Specific operation: The server notifies the user that the document is complete.

[1367] Input: Saved material data.

[1368] Output: A notification message to the user.

[1369] Data processing / data calculation: The server generates a notification message and sends it to the user, including the link and file name of the material.

[1370] Step 10:

[1371] Processing feedback and updating learnings

[1372] Specific operation: The user reviews the generated materials and provides feedback. The server receives the feedback, analyzes it, and updates the learning data.

[1373] Input: User feedback data.

[1374] Output: Updated training data.

[1375] Data processing / data calculation: The server analyzes the feedback, reflects the content in the learning data, and applies it to the next document creation.

[1376] (Application example 2)

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

[1378] In modern factories, many robots are in operation, and managing them requires a great deal of time and effort. Furthermore, the emotions and stress levels of managers often affect the quality of their work. A method is needed to solve these problems and generate efficient, user-friendly robot management reports.

[1379] 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 a user to input a request for document creation; means for analyzing the input request; means for learning based on the user's past documents and preferences; means for planning document creation based on the learning results; means for automatically generating appropriate figures and tables; means for formatting and editing the generated figures and tables; means for saving the generated documents and notifying the user; means for receiving user feedback and updating the learning data; and means for including an emotion recognition engine that recognizes the user's emotional state and adjusting the design and content of the documents according to the emotional state. This enables efficient and high-quality robot management reports to be generated while taking into account the emotional state of the manager.

[1380] The "means for the user to input a request for material creation" refers to an interface through which the user inputs specific requests for material creation using his / her own terminal.

[1381] The "means for analyzing an input request" refers to a software module that analyzes a request input by a user and identifies and classifies the request content.

[1382] "Means for learning based on the user's past materials and preferences" refers to an algorithm that acquires the user's past material data and preference patterns stored in a database and learns from them using a machine learning model.

[1383] "Means for planning the generation of materials based on learning results" refers to a planning module that plans what information to include in the materials and in what format based on learning results.

[1384] "Means for automatically generating appropriate figures and tables" refers to a function that uses a chart generation API based on a plan to automatically generate appropriate figures and tables.

[1385] "Means for formatting and editing the generated figures and tables" refers to software tools that are used to format the generated figures and tables to fit the design and layout of the document and make any necessary edits.

[1386] "Means for saving the generated materials and notifying the user" refers to a communication module that saves the completed materials in a database and notifies the user of the link and file name.

[1387] The "means for receiving user feedback and updating learning data" refers to a control program that receives feedback from users, analyzes the content of the feedback, and updates the learning data.

[1388] "Means for adjusting the design and content of materials according to the emotional state, including an emotion recognition engine" refers to an engine that analyzes the user's emotions and an algorithm that optimizes the design and content of materials according to the emotional state.

[1389] This invention is a system for efficiently managing robot operation data and maintenance information in factory management, thereby reducing the stress of managers. This system is implemented through the following steps.

[1390] System Overview:

[1391] The system receives requests for document creation from users, analyzes them, learns from them, plans them, automatically generates appropriate diagrams and tables, and finally provides them as documents. During this process, it uses an emotion recognition engine to recognize the user's emotional state and optimize the document creation process.

[1392] Hardware and software:

[1393] Smartphone: Used by the user to input requests for material creation.

[1394] Head-mounted display: Used by the user to view the generated materials.

[1395] Emotion recognition engine: Software that analyzes user input and recognizes their emotional state.

[1396] Chart generation API: An API for automatically generating charts and tables based on your requests.

[1397] Databases (e.g., Firebase): Used to store and retrieve user history and preferences.

[1398] Notification Service: A service for notifying users of the link and file name of the completed document.

[1399] Examples:

[1400] When a user wants to create a new robot operation report, they use their smartphone to enter the following request:

[1401] Title: "Robot Operation Report"

[1402] Information included: "Operating time", "Failure rate", "Maintenance history"

[1403] Desired table or graph: "Bar chart", "Pie chart"

[1404] The server analyzes this request and learns from the user's past materials and preferences. It also uses an emotion recognition engine to recognize the user's emotional state (e.g., tension or stress). It then creates a material generation plan that takes into account the learning results and the user's emotional state. Based on this plan, it automatically generates appropriate diagrams and tables using a diagram generation API.

[1405] The generated diagrams and tables are formatted and edited in a design optimized for the user's emotional state and saved as the final document in the database. Once the document is complete, a notification is sent to the user via a notification service. The system is continuously improved as users review the document and provide feedback.

[1406] Example prompt sentence:

[1407] "We understand that users are nervous. Please generate a simple, easy-to-read 'Robot Operation Report' for them. The report should include bar charts and pie charts with uptime, failure rate, and maintenance history."

[1408] In this way, the system can take into account the emotional state of the manager and automatically generate efficient and high-quality robot management reports, thereby reducing the burden of work.

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

[1410] Step 1:

[1411] The user inputs a request for document creation. Using a terminal, the user inputs the document title, the information to be included, the desired type of chart, etc. This input data is sent to the server. The input data includes "robot operation report," "operation time," "failure rate," "maintenance history," "bar chart," "pie chart," etc.

[1412] Step 2:

[1413] The server analyzes the input request. The server analyzes the received request data and identifies the document title, the information to be included, the desired type of chart, etc. The analysis results are stored in an internal data structure. For example, the server identifies "Robot Operation Report" as the title and classifies "Operation Hours," "Failure Rate," and "Maintenance History" as the required information.

[1414] Step 3:

[1415] The server learns based on the user's past data and preferences. The server retrieves the user's past data and design preferences from a database. This data is input into a machine learning algorithm to learn the user's preferences and trends. For example, it analyzes past robot reports and design patterns.

[1416] Step 4:

[1417] The server creates a plan for generating materials based on the learning results. Based on the acquired data and the learned user preferences, it plans what information to include in the materials and in what format. This plan may include, for example, using a bar chart for "operating time" and a pie chart for "failure rate."

[1418] Step 5:

[1419] The server uses an emotion recognition engine to recognize the user's emotional state. It analyzes the user's typing speed and click patterns to estimate their emotional state, such as tension or stress. The results are used to adjust the design and content of the materials.

[1420] Step 6:

[1421] The server automatically generates the appropriate charts and tables. Based on the plan, it sends a request to the chart generation API to generate the necessary charts (bar charts and pie charts). For example, it generates a bar chart using the "uptime" data and a pie chart using the "failure rate" data.

[1422] Step 7:

[1423] The server formats and edits the generated diagrams and tables. It places the generated diagrams and tables into a document template and adjusts the design and layout based on the user's emotional state. For example, if the user is nervous, it will create a simple, easy-to-read layout.

[1424] Step 8:

[1425] The server saves the generated document and notifies the user. The server saves the final document in PDF or PPTX format and notifies the user of the link and file name. The notification includes a download link for the generated document.

[1426] Step 9:

[1427] The user provides feedback. Through the terminal, the user inputs feedback on the generated materials. The feedback includes corrections and improvements.

[1428] Step 10:

[1429] The server analyzes user feedback and updates the learning data. The provided feedback is analyzed and reflected in the next data generation along with the emotion engine data. This allows the system to continuously improve.

[1430] This series of steps enables efficient and high-quality robot management reports to be automatically generated while taking into consideration the user's emotional state.

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

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

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

[1434] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1448] The system of the present invention allows users to input their requirements for creating materials, automatically generates appropriate figures and tables based on those requirements, and provides the final materials. The program processing of this system is explained below in natural language, and specific examples are also provided.

[1449] System Overview

[1450] The system begins with the user inputting their document requirements, analyzes those requirements, and automatically generates high-quality documents based on the user's preferences. The server learns from the user's past documents and preferences, and based on that, creates an optimal plan for document generation, automatically generating appropriate figures and tables using a diagram generation API. The final document is saved and notified to the user. The system also incorporates user feedback to continuously improve it.

[1451] Detailed program processing

[1452] 1. User request input

[1453] Users use a terminal to input a document creation request, which includes the document title, the information to be included (e.g., schedule progress, budget utilization, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart).

[1454] The terminal transmits the request entered by the user to the server.

[1455] 2. Request Analysis

[1456] The server analyzes the received request, which involves identifying and classifying the request content (e.g., identifying the title, schedule progress, budget utilization, risk assessment, etc.).

[1457] The analysis results are stored in an internal data structure.

[1458] 3. Acquiring and analyzing user learning data

[1459] The server retrieves data about the user's past records and preferences from a database.

[1460] Using this data, natural language processing algorithms analyze user preferences and style, learning, for example, specific color tones, fonts, and layout patterns.

[1461] 4. Planning the data generation plan

[1462] Based on the learning results and the analyzed requirements, the server creates a plan for generating materials, detailing which charts to use and what content to include.

[1463] 5. Automatic generation of charts and graphs

[1464] The server sends a request to the chart generation API to generate the appropriate chart (e.g., Gantt chart, pie chart, quantitative table) based on the plan.

[1465] The chart generation API generates charts and tables according to the request and returns them to the server.

[1466] 6. Editing and formatting materials

[1467] The server places the generated figures and tables into a document template.

[1468] Based on the user's preferences, the design and layout are adjusted as necessary, for example, adjusting the order of figures and tables, color consistency, font style, etc.

[1469] The completed materials are converted into a document format (e.g. PDF, PPTX).

[1470] 7. Material Retention and Notification

[1471] The server stores the completed documents in a database.

[1472] The user is notified that the document is complete, including a link to the document and the file name.

[1473] 8. Processing feedback and updating learnings

[1474] The user uses the terminal to check the generated materials and input feedback if necessary.

[1475] The feedback provided by the user is sent to the server and analyzed.

[1476] The server updates the learning data based on the feedback and reflects it in the next document creation.

[1477] Specific examples

[1478] For example, consider the case where user A wants to create a progress report for a new project. User A enters the following request from his terminal:

[1479] Title: "Project A Progress Report"

[1480] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[1481] Preferred table or graph: "Gantt chart", "pie chart"

[1482] The server receives this request, learns from past documents and preferences, and creates a plan. It then automatically generates the necessary diagrams using a diagram generation API. The final report is formatted and edited in a format that suits User A's preferences, and User A is notified once it is complete. User A can review the completed document and provide feedback, which will be used to continuously improve the system.

[1483] In this way, the system of the present invention can efficiently create high-quality materials that meet the user's requirements.

[1484] The processing flow will be explained below.

[1485] Step 1:

[1486] The user inputs a document creation request from a terminal. The request includes the document title, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The terminal then sends the input request to the server.

[1487] Step 2:

[1488] The server parses the received request, identifying and categorizing the request content (e.g., identifying title, schedule progress, budget utilization, risk assessment, etc.), and stores the results of the analysis in an internal data structure.

[1489] Step 3:

[1490] The server retrieves data about the user's past materials and preferences from a database, including previously created reports and presentations, and the user's design preferences.

[1491] Step 4:

[1492] The server uses the acquired data to run natural language processing algorithms to analyze user preferences and style, learning specific color tones, fonts, layout patterns, etc.

[1493] Step 5:

[1494] Based on the learning results and the analyzed requirements, the server creates a plan for generating materials, detailing which charts to use and what content to include.

[1495] Step 6:

[1496] The server sends a request to the chart generation API to generate the appropriate chart (e.g., Gantt chart, pie chart, quantitative table) based on the plan. The chart generation API generates the chart or table according to the request and returns it to the server.

[1497] Step 7:

[1498] The server places the generated figures and tables into a document template, and adjusts the design and layout as needed based on the user's preferences, such as adjusting the order of figures and tables, color consistency, font style, etc.

[1499] Step 8:

[1500] The server converts the completed materials into a document format (e.g. PDF, PPTX), and once the materials have been formatted and edited, they are stored in the database.

[1501] Step 9:

[1502] The server notifies the user that the document is complete, including a link to the document and its file name.

[1503] Step 10:

[1504] The user can check the generated materials on the terminal and enter feedback if necessary, including suggestions for corrections and improvements.

[1505] Step 11:

[1506] The server receives and analyzes the user's feedback, updates the learning data based on the feedback, and reflects it in the next document creation.

[1507] Example 1

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

[1509] The conventional document creation process required a lot of time and effort, making it difficult to create efficient, high-quality documents quickly. Furthermore, it was difficult to automatically generate documents tailored to individual user preferences, creating a need for improved user satisfaction.

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

[1511] In this invention, the server includes means for inputting user requests, means for analyzing the requests, means for learning based on the user's past materials and preferences, means for planning material generation based on the learning results, means for automatically generating appropriate figures and tables, means for formatting and editing the generated figures and tables, means for saving the generated materials and notifying the user, means for receiving user feedback and updating the learning data, means for analyzing input from the terminal and creating a plan on the server, means for using a diagram generation API for automatically generating specific diagrams and tables, and means for arranging the automatically generated materials in a template and adjusting the design based on the user's preferences. This enables efficient and high-quality material creation and enables materials tailored to the preferences of individual users to be quickly provided.

[1512] A "user" is an entity that uses the system to input a request for material creation.

[1513] The "means for inputting requests" refers to a method or device that allows a user to provide the system with the information or requests required for creating materials.

[1514] "Means for analyzing requirements" is the process of breaking down input requirements, classifying them into specific categories, and understanding them.

[1515] "Means for learning based on the user's past materials and preferences" refers to a method for analyzing past materials and the user's usage history to understand the user's preferences and style.

[1516] "Means for planning material generation" is the process of creating a plan for how to compose materials based on the analyzed requirements and learning results.

[1517] "Means for automatically generating appropriate figures and tables" refers to a method for automatically creating figures and tables to be included in the materials.

[1518] A "diagram generation API" is a program interface that uses external services or software to generate diagrams in a specified format.

[1519] "Means for formatting and editing generated figures and tables" refers to methods for formatting automatically generated figures and tables, and is the process of adjusting the design and layout to suit the user's preferences.

[1520] The "means for storing the generated materials and notifying the user" refers to a method for safely storing the generated materials and notifying the user when the materials are completed.

[1521] "Means for receiving user feedback and updating learning data" refers to the process of collecting opinions and suggestions for improvement from users and improving the system's learning data based on them.

[1522] "Means for analyzing input from a terminal and creating a plan at a server" refers to a method in which a server receives a request input by a user through a terminal, analyzes it, and creates a plan for generating materials.

[1523] "Means for placing automatically generated materials in a template and adjusting the design based on the user's preferences" refers to the process of fitting the generated materials into a specified format and, if necessary, making design modifications to suit the user's preferences.

[1524] The system of the present invention starts when a user requests the creation of a document. The specific processing flow and operation of the system will be explained below.

[1525] A user uses a terminal to input a request for the creation of a document. The request includes the title of the document, the information to be included, the type of chart desired, etc. For example, when creating a project progress report, the user inputs the title "Project A Progress Report," information such as "Schedule Progress," "Budget Usage Status," and "Risk Assessment," as well as a request for charts such as a "Gantt Chart" or "Pie Chart."

[1526] The terminal sends the user's input to the server. The server analyzes the received request, breaks it down into a specific data structure, and stores it. Through the analysis, the request content (e.g., document title, schedule progress, budget usage, risk assessment, etc.) becomes clear.

[1527] The server then retrieves data about the user's past materials and preferences from a database and uses natural language processing algorithms to analyze the user's preferences and style, for example learning the font styles and color palettes the user has used in the past.

[1528] The server creates a plan for generating materials based on the learning results. This plan includes specific details such as which diagrams to place where and what content they should contain. After the plan is created, the server sends a request to the diagram generation API to generate the necessary diagrams (e.g., Gantt charts, pie charts).

[1529] The diagram generation API generates diagrams in the specified format in response to a request and returns the results to the server, which places the generated diagrams in a document template and adjusts the design and layout as needed based on the user's preferences, such as adjusting the diagram order, color matching, and font style.

[1530] The final document is converted into the specified document format (e.g., PDF, PPTX) and saved in the database by the server. The server notifies the user that the document is complete, and the notification includes a link to the document and its file name.

[1531] If the user wants to review the generated materials and provide feedback, they can enter it on their device. The feedback is sent to the server, which analyzes it and updates the system's learning data. This allows the feedback to be reflected the next time materials are created, allowing the system to continuously improve.

[1532] Examples of concrete examples and prompts

[1533] For example, consider a situation where user A wants to create a progress report for a new project. User A enters the following request into his terminal:

[1534] Title: "Project A Progress Report"

[1535] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[1536] Preferred table or graph: "Gantt chart", "pie chart"

[1537] Based on this request, the server generates the materials and provides the final report to User A. An example of a prompt sentence to input to the generative AI model is as follows:

[1538] I'd like to create a progress report for a new project. Please include the following required information:

[1539] Title: "Project A Progress Report"

[1540] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[1541] Preferred table or graph: "Gantt chart", "pie chart"

[1542] In this way, this system can efficiently create high-quality materials that meet the user's requirements.

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

[1544] Step 1:

[1545] The user inputs a request for material creation.

[1546] The user uses a terminal to input the title of the document, the information to be included, and the type of chart or diagram desired. For example, the user inputs the title "Project A Progress Report," the information to be included is "Schedule Progress," "Budget Usage Status," and "Risk Assessment," and the chart or diagram desired is "Gantt Chart" or "Pie Chart."

[1547] Input: Title of the document, information to include, desired type of chart

[1548] Output: User request data

[1549] Step 2:

[1550] The terminal sends the user's request to the server.

[1551] The terminal transmits the input request data to the server, which then receives the user's request for creating a document.

[1552] Input: User request data

[1553] Output: Sending the request data to the server

[1554] Step 3:

[1555] The server analyzes the request received from the user.

[1556] The server analyzes the request data, breaks down the request content into specific data structures, and stores them. For example, it identifies elements such as "title," "schedule progress," "budget usage," and "risk assessment."

[1557] Input: Request data

[1558] Output: Parsed request data

[1559] Step 4:

[1560] The server retrieves data about the user's past records and preferences from a database.

[1561] The server retrieves the user's past and preference data from a database and uses natural language processing algorithms to analyze the user's preferences and style, for example, learning specific font styles and color palettes.

[1562] Input: Parsed request data

[1563] Output: User's training data

[1564] Step 5:

[1565] The server creates a plan for generating materials based on the learning results.

[1566] The server creates a plan for generating materials based on the analyzed requests and learning results, including details such as which information to place in which charts.

[1567] Input: User training data

[1568] Output: Data generation plan

[1569] Step 6:

[1570] The server sends a request to the diagram generation API, requesting that a diagram be automatically generated based on the plan.

[1571] The server sends a request to the chart generation API, instructing it to generate charts such as Gantt charts, pie charts, etc. The chart generation API generates charts and tables according to the request and returns the results to the server.

[1572] Input: Data Generation Plan

[1573] Output: Generated chart data

[1574] Step 7:

[1575] The server places the generated diagrams and tables into a document template and adjusts the design and layout as needed.

[1576] The server places the generated diagrams into a document template and adjusts the design and layout based on the user's preferences, such as adjusting the diagram order, color consistency, and font style.

[1577] Input: Generated chart data

[1578] Output: Formatted and edited data

[1579] Step 8:

[1580] The server converts the completed materials into a document format and stores them in a database.

[1581] The server converts the formatted and edited data into PDF or PPTX format, stores it in the database, and notifies the user that the data is complete. The notification includes a link to the data and the file name.

[1582] Input: Formatted and edited data

[1583] Output: Documentation, user notifications

[1584] Step 9:

[1585] The user reviews the generated material and provides feedback.

[1586] The user can use the device to check the generated data and enter feedback as needed. For example, they can enter feedback such as "I would like the colors of the Gantt chart to be a little brighter." The feedback is sent from the device to the server.

[1587] Input: Generated materials, user feedback

[1588] Output: Feedback data

[1589] Step 10:

[1590] The server analyzes the feedback and updates the training data.

[1591] The server analyzes the feedback data and updates the system's learning data, so that the feedback is reflected in the next document creation, allowing the system to continuously improve.

[1592] Input: Feedback data

[1593] Output: Updated training data

[1594] The above are the specific operations and steps in the processing flow of the program of this system.

[1595] (Application example 1)

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

[1597] At logistics centers, managers need to accurately and quickly grasp inventory status and shipping progress, but manually collecting data and creating documents takes time and effort. It is also difficult to create reports based on past documents or in a format that suits the manager's preferences. This hinders efficient operations.

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

[1599] In this invention, the server includes: means for a user to input a request for document creation; means for analyzing the input request; means for learning based on the user's past documents and preferences; means for planning document creation based on the learning results; means for automatically generating appropriate figures and tables; means for formatting and editing the generated figures and tables; means for saving the generated documents and notifying the user; means for receiving user feedback and updating the learning data; means for acquiring necessary data from a database or API; means for performing data analysis and generating graphs; and means for linking with a business system to acquire data in real time. This enables managers to efficiently create high-quality reports and quickly grasp the operating status of the logistics center.

[1600] The "means for a user to input a request for creating a material" is an interface that allows a logged-in user to input a request for creating a material containing specific information.

[1601] The "means for analyzing the input request" is an algorithm for analyzing the content of the request for creating a document input by the user and identifying the type of data and charts required.

[1602] The "means for learning based on the user's past materials and preferences" is a machine learning model for learning based on materials created by the user in the past and the user's preferred designs and formats.

[1603] "Means for planning the generation of materials based on learning results" is a mechanism for planning the format in which materials should be created based on the learned data.

[1604] The "means for automatically generating appropriate figures and tables" is a software module for automatically generating necessary figures and tables based on the plan.

[1605] "Means for formatting and editing the generated figures and tables" refers to tools for formatting the generated figures and tables to fit the format of the document and adjusting the design as necessary.

[1606] "Means for saving generated materials and notifying users" refers to a system for saving completed materials and notifying users of their links or files.

[1607] The "means for receiving user feedback and updating learning data" is an algorithm for receiving feedback from users and reflecting that feedback in the next document creation.

[1608] "Means for obtaining necessary data from a database or API" refers to an interface for obtaining data necessary for document creation from a database or external API.

[1609] "Means for data analysis and graph generation" refers to the process for analyzing acquired data and generating graphs and tables in the format required for the report.

[1610] "Means of linking with business systems to obtain data in real time" refers to a mechanism that links with the logistics center's business systems to obtain the necessary data in real time.

[1611] The system of the present invention can automatically generate reports to support the work of a manager at a logistics center. A specific embodiment of the system will be described below.

[1612] System Configuration

[1613] This system mainly consists of a server, a user device (smartphone), various sensors, and an API. The server receives requests from users and manages a series of processes that automatically generate reports based on those requests. The user device is used to input requests for report creation and provide feedback.

[1614] Program processing overview

[1615] Hardware and Software

[1616] Hardware

[1617] server

[1618] Smartphone

[1619] Internet connection

[1620] Various sensors (inventory sensors, shipping sensors, etc.)

[1621] software

[1622] Flask (for the API)

[1623] Pandas (for data manipulation)

[1624] Matplotlib (for generating graphs)

[1625] Database management system (e.g. MySQL)

[1626] Chart generation API (e.g. Google Charts API)

[1627] Detailed process description

[1628] 1. User request input

[1629] The user inputs a request for report creation using a smartphone, which specifically includes information such as "inventory status" and "shipping progress."

[1630] 2. Request Analysis

[1631] The server analyzes the request sent by the user and identifies the required data.

[1632] 3. Acquisition and analysis of training data

[1633] The server retrieves and analyzes data about the user's past materials and preferences from a database, thereby learning the user's preferences and style.

[1634] 4. Planning the data generation plan

[1635] Based on the learning results and requirements, plan the format in which the report will be prepared.

[1636] 5. Obtaining the necessary data

[1637] Get real-time inventory and shipping progress data from a database or API.

[1638] 6. Data analysis and graph generation

[1639] The acquired data is analyzed and charts (e.g., bar graphs, Pareto charts) are generated to show inventory status and shipping progress.

[1640] 7. Editing and formatting materials

[1641] The generated charts and graphs are formatted based on the report template, and the design is adjusted as necessary.

[1642] 8. Material Retention and Notification

[1643] The completed report is saved on an internet drive and the link is sent to the user.

[1644] 9. Get feedback and improve

[1645] It receives feedback from users, updates the learning data based on that feedback, and reflects it in subsequent report creation.

[1646] Specific examples

[1647] For example, if a logistics center manager wants to create a report that includes "This month's inventory status and shipping progress," he or she can enter the following request on a smartphone:

[1648] Prompt Sentence Examples

[1649] "Please prepare a report on this month's inventory status and shipping progress. Specifically, please include a bar graph of inventory and a Pareto chart of shipping status."

[1650] The server analyzes these requests, obtains the necessary information in real time, automatically generates a report, and notifies the manager. This system enables logistics center managers to efficiently create reports and quickly grasp the operational status.

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

[1652] Step 1: User enters a request for material creation

[1653] A user uses a smartphone to input a request to create a report. The request includes specific information (e.g., "This month's inventory status and shipping progress") and the desired type of chart (e.g., "Bar graph of inventory and Pareto chart of shipping status"). This input is sent from the device to the server.

[1654] Input: User request (e.g., "This month's inventory status and shipping progress")

[1655] Output: Request data containing the request content

[1656] Step 2: Parse the incoming request

[1657] The server receives the request sent by the user and begins analyzing it. During analysis, the request is identified and classified (e.g., "Stock status" or "Shipping progress"). At this stage, it is determined what data is required.

[1658] Input: Request data containing the requested content

[1659] Output: Analysis results (identification of required data)

[1660] Step 3: Obtain and analyze user learning data

[1661] The server retrieves data on past materials and user preferences from a database, and then uses natural language processing algorithms to analyze user preferences for design and formatting.

[1662] Input: Past data, user preference data

[1663] Output: Analysis of user preferences and styles

[1664] Step 4: Create a material generation plan

[1665] The server creates a report generation plan based on the analysis results and learning data, including the types and formats of charts and graphs to be used, and their display order.

[1666] Input: Analysis results, analysis of user preferences and style

[1667] Output: Report generation plan

[1668] Step 5: Get the data you need

[1669] The server retrieves the necessary inventory data and shipping progress data in real time from a database or external API based on the analysis results.

[1670] Input: Analysis results

[1671] Output: Inventory data, shipping progress data

[1672] Step 6: Analyze data and generate graphs

[1673] The server analyzes the acquired data and generates charts in the specified format (e.g., inventory bar graph, shipment Pareto chart). It uses Pandas to preprocess the data and Matplotlib to generate the charts.

[1674] Input: Inventory data, shipping progress data

[1675] Output: The generated diagram

[1676] Step 7: Edit and format your materials

[1677] The server includes the generated charts in a report, formats them based on a template, and makes any necessary design adjustments (color and font consistency).

[1678] Input: Generated charts, report generation plans

[1679] Output: A formatted report

[1680] Step 8: Save the material and notify users

[1681] The server stores the completed report and sends a link to the user via a smartphone application.

[1682] Input: Formatted report

[1683] Output: Saved report, notification link

[1684] Step 9: Get user feedback and update the training data

[1685] The user reviews the report and provides feedback, which the server receives and updates the learning data to reflect in future report generation.

[1686] Input: User feedback

[1687] Output: Updated training data, reflected in next data generation

[1688] The above are the specific processing steps and their contents. This system enables the logistics center manager to efficiently create high-quality reports and quickly grasp the operational status.

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

[1690] The system of the present invention allows users to input their document creation requirements, automatically generates appropriate figures and tables based on those requirements, and provides the final document. The system learns from the user's past documents and preferences, and uses this information to create an optimal plan for document generation. It then uses a diagram generation API to automatically generate diagrams as needed. The final document is saved and notified to the user. Furthermore, the system incorporates user feedback to continuously improve the system.

[1691] One of the features of this invention is the function of optimizing the document creation process according to the user's emotional state by combining it with an emotion engine that recognizes the user's emotions. Below, the program processing of this system is explained in natural language.

[1692] System Overview

[1693] The system receives the user's document creation request, analyzes it, learns from it, plans it, and then formats and edits the automatically generated figures and tables to provide the final document. In addition, it uses an emotion engine to recognize the user's emotional state and reflects the results in the design and content of the document.

[1694] Detailed program processing

[1695] 1. User request input

[1696] The user inputs a document creation request from a terminal. The request includes the document title, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The terminal then sends the request to the server.

[1697] 2. Request Analysis

[1698] The server parses the received request, identifying and categorizing the request content (e.g., identifying title, schedule progress, budget utilization, risk assessment, etc.), and stores the results of the analysis in an internal data structure.

[1699] 3. Acquiring and analyzing user learning data

[1700] The server retrieves data about the user's past materials and preferences from a database, including previously created reports and presentations, and the user's design preferences.

[1701] 4. Emotion recognition

[1702] The server utilizes an emotion engine to recognize the emotion of the user when inputting a request. The emotion engine analyzes the user's input and interactions and estimates their emotional state.

[1703] 5. Integrating learning outcomes and emotions

[1704] The server combines the acquired data with the results of emotion recognition and creates a plan for generating materials, taking into account the user's preferences and current emotional state. This plan details which charts to use and what content to include.

[1705] 6. Automatic generation of charts and graphs

[1706] The server sends a request to the chart generation API to generate the appropriate chart based on the plan, and the chart generation API generates charts and tables according to the request and returns them to the server.

[1707] 7. Editing and formatting materials

[1708] The server places the generated figures and tables into a document template, adjusting the design and layout as needed based on the user's preferences and emotional state. For example, if the user is feeling stressed, it will select a simple, easy-to-read layout.

[1709] 8. Material Retention and Notification

[1710] The server converts the completed materials into a document format (e.g. PDF, PPTX), and once the materials have been formatted and edited, they are stored in the database.

[1711] 9. Notification

[1712] The server notifies the user that the document is complete, including a link to the document and its file name.

[1713] 10. Processing feedback and updating learnings

[1714] The user can check the generated materials on the terminal and enter feedback if necessary, including suggestions for corrections and improvements.

[1715] The server receives user feedback, analyzes it, and updates the learning data based on the feedback and emotion engine data, which is then reflected in the next document creation.

[1716] Specific examples

[1717] For example, consider the case where user A wants to create a progress report for a new project. User A enters the following request from his terminal:

[1718] Title: "Project A Progress Report"

[1719] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[1720] Preferred table or graph: "Gantt chart", "pie chart"

[1721] Furthermore, the emotion engine recognizes that User A is nervous. The server integrates this emotion data with past document data to create an optimal plan. It then automatically generates appropriate diagrams using a diagram generation API. The final report is formatted and edited in a format that suits User A's preferences and current emotional state, and is notified to User A once it is complete. User A can provide feedback after checking the report, which further improves the system.

[1722] In this way, the system of the present invention can efficiently create high-quality materials that meet the user's needs and emotional state.

[1723] The processing flow will be explained below.

[1724] The system of the present invention allows users to input their document creation requirements, automatically generates appropriate figures and tables based on those requirements, and provides the final document. The system learns from the user's past documents and preferences, and uses this information to create an optimal plan for document generation. It then uses a diagram generation API to automatically generate diagrams as needed. The final document is saved and notified to the user. Furthermore, the system incorporates user feedback to continuously improve the system.

[1725] One of the features of this invention is the function of optimizing the document creation process according to the user's emotional state by combining it with an emotion engine that recognizes the user's emotions. Below, the program processing of this system is explained in natural language.

[1726] Step 1:

[1727] The user inputs a document creation request from a terminal. The request includes the document title, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The terminal then sends the input request to the server.

[1728] Step 2:

[1729] The server parses the received request, identifying and categorizing the request content (e.g., identifying title, schedule progress, budget utilization, risk assessment, etc.), and stores the results of the analysis in an internal data structure.

[1730] Step 3:

[1731] The server retrieves data about the user's past materials and preferences from a database, including previously created reports and presentations, and the user's design preferences.

[1732] Step 4:

[1733] The server uses the acquired data to run natural language processing algorithms to analyze user preferences and style, learning specific color tones, fonts, layout patterns, etc.

[1734] Step 5:

[1735] The server utilizes an emotion engine to recognize the emotion of the user when inputting a request. The emotion engine analyzes the user's input and interactions, and estimates and classifies their emotional state (e.g., stress, joy, excitement, etc.).

[1736] Step 6:

[1737] The server combines the acquired data with the results of emotion recognition and creates a plan for generating materials, taking into account the user's preferences and current emotional state. This plan details which charts to use and what content to include.

[1738] Step 7:

[1739] The server sends a request to the chart generation API, which generates the appropriate charts based on the plan. The chart generation API generates charts and tables according to the request and returns them to the server.

[1740] Step 8:

[1741] The server places the generated figures and tables into a document template, adjusting the design and layout based on the user's preferences and emotional state. For example, if the user is feeling stressed, a simple, easy-to-read layout and a calm color scheme are selected.

[1742] Step 9:

[1743] The server converts the material into a document format (e.g. PDF, PPTX), and once formatting and editing are complete, it stores the resulting material in a database.

[1744] Step 10:

[1745] The server notifies the user that the document is complete, including a link to the document and its file name.

[1746] Step 11:

[1747] The user can check the generated materials on the terminal and enter feedback if necessary, including suggestions for corrections and improvements.

[1748] Step 12:

[1749] The server receives user feedback, analyzes it, and updates the learning data based on the feedback and emotion engine data, which is then reflected in the next document creation.

[1750] As a concrete example, let us consider the case where User A is creating a progress report for a new project. User A inputs the following requests from the terminal: "Project A Progress Report", "Schedule Progress", "Budget Usage", "Risk Assessment", "Gantt Chart" and "Pie Chart". The emotion engine recognizes that User A is nervous.

[1751] The server integrates this emotional data with past document data to create an optimal plan. It then automatically generates the necessary diagrams using a diagram generation API. The final report is formatted and edited in a format that matches User A's preferences and current emotional state. Once completed, User A is notified, and User A can provide feedback after reviewing the report, which further improves the system. In this way, the system of the present invention can efficiently create high-quality documents that meet the user's requests and emotional state.

[1752] Example 2

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

[1754] In today's business environment, efficient and high-quality document creation is essential. However, conventional document creation processes require a great deal of time and effort, making it difficult to create documents that reflect the user's preferences and emotional state. Meanwhile, there is a problem in that methods for automatically generating appropriate figures and tables and providing them in an optimal format to the user are not functioning effectively. The present invention aims to provide a system that automatically generates efficient, personalized documents that take into account the user's preferences and emotional state.

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

[1756] In this invention, the server includes means for a user to input a request for creating a document, means for analyzing the input request, means for learning based on the user's past documents and preferences, means for planning document creation based on the learning results, means for automatically generating appropriate figures and tables, means for formatting and editing the generated figures and tables, means for saving the generated documents and notifying the user, means for receiving user feedback and updating the learning data, and means for recognizing the user's emotional state and optimizing the document creation process based on the emotion. This enables efficient creation of high-quality documents according to the user's request and emotional state.

[1757] The "means for users to input requests for creating materials" refers to an interface that allows users to input requests to the system via a terminal by specifying the title of the material, the information to be included, the type of charts and diagrams desired, etc.

[1758] The "means for analyzing input requests" refers to a processing function that analyzes the document creation request received by the server from the user and identifies and classifies the title, included information, type of chart, etc.

[1759] "Means for learning based on the user's past data and preferences" refers to a function in which the server retrieves the user's past data and preference data from a database, analyzes it, and learns the user's patterns and preferences.

[1760] The "means for planning material generation based on learning results" is a function that combines acquired learning data with information on emotional state to formulate an optimal material generation plan.

[1761] The "means for automatically generating appropriate charts and tables" is a function in which the server uses a chart generation API to automatically create appropriate charts and tables based on the user's requests and plans.

[1762] "Means for formatting and editing the generated figures and tables" refers to a function in which the server places the generated figures and tables in a document template and adjusts the layout and design to suit the user's preferences and emotional state.

[1763] The "means for saving the generated materials and notifying the user" is a function for converting the completed materials into a specified document format, saving them in a database, and sending a notification to inform the user.

[1764] The "means for receiving user feedback and updating learning data" is a function that analyzes the feedback provided by the user regarding the generated materials, updates the learning data based on that feedback, and reflects it in the next material creation.

[1765] "Means for recognizing the user's emotional state and optimizing the document creation process based on that emotion" is a function that uses an emotion engine to recognize the user's emotional state and reflects that information in the document creation process to optimize it.

[1766] "Figure Generation API" is an application program interface for generating figures and tables used in materials.

[1767] The system of the present invention is an information processing system in which a user inputs a request for creating a document, and appropriate figures and tables are automatically generated based on the request, and the final document is provided. A description will now be given of an embodiment of the present invention.

[1768] First, a user inputs a request for document creation using a terminal. This request includes the title of the document, the information to be included (e.g., schedule progress, budget usage, risk assessment), and the desired type of diagram (e.g., Gantt chart, pie chart). The input information is sent from the terminal to the server.

[1769] The server analyzes the received request. Specifically, it identifies the request content and classifies and extracts information such as the title and schedule progress. The results of this analysis are stored in an internal data structure.

[1770] The server then retrieves data about the user's past documents and preferences from a database, including past reports and presentations, the user's design preferences, etc. The server analyzes this data to learn the user's patterns and preferences.

[1771] The server also uses an emotion engine to recognize the user's emotional state. The emotion engine estimates the user's emotional state based on the user's input and interactions and provides the results to the server. For example, it can recognize the user's level of tension when inputting information.

[1772] By integrating the acquired training data and the emotion recognition results, the server creates an optimal plan for generating materials, which details which charts to use and what content to include.

[1773] The server then sends a request to the chart generation API to generate the appropriate charts and tables based on the plan. The chart generation API generates the charts and tables according to the request and sends the results back to the server.

[1774] The server then places the generated diagrams into a document template, adjusting the design and layout as needed based on the user's preferences and emotional state. For example, if the user is feeling stressed, a simple, easy-to-read layout is selected.

[1775] The completed document is converted into a document format (e.g., PDF, PPTX) by the server and saved in the database. The server then notifies the user that the document is complete. The notification includes the document link and file name.

[1776] The user checks the completed document and provides feedback as needed. The server receives the feedback, analyzes the content, and updates the learning data, which is then reflected in the next document creation.

[1777] As a concrete example, consider the case where user A wants to create a progress report for a new project. User A enters the following request into the terminal:

[1778] Title: "Project A Progress Report"

[1779] Information included: "Schedule progress", "Budget utilization", "Risk assessment"

[1780] Preferred table or graph: "Gantt chart", "pie chart"

[1781] Furthermore, the emotion engine recognizes that User A is nervous. The server integrates this emotion data with past document data to create an optimal plan. It then automatically generates an appropriate diagram using a diagram generation API. The final report is formatted and edited in a format that suits User A's preferences and current emotional state, and is notified to User A once it is complete. User A can provide feedback after reviewing the report, further improving the system.

[1782] In this way, the system of the present invention can efficiently create high-quality materials that meet the user's needs and emotional state.

[1783] Example prompt sentence:

[1784] Create a progress report for Project A. Include information on schedule progress, budget utilization, and risk assessment. Gantt charts and pie charts are preferred for tables and graphs. Also, consider the user's emotional state and adjust the layout to be simple and easy to read.

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

[1786] Step 1:

[1787] User request input

[1788] Specific operation: The user inputs a request for creating a document from the terminal.

[1789] Input: Title, information to include (e.g., schedule progress, budget usage, risk assessment), desired chart type (e.g., Gantt chart, pie chart).

[1790] Output: The request data sent from the device to the server.

[1791] Data processing / data calculation: The terminal collects user input and sends it to the server as structured request data.

[1792] Step 2:

[1793] Parsing the request

[1794] Specific operation: The server analyzes the received request.

[1795] Input: The request data received in step 1.

[1796] Output: An internal data structure containing the analysis results.

[1797] Data processing / data calculation: The server identifies the requested content and classifies and extracts the title and each information item.

[1798] Step 3:

[1799] Acquiring and analyzing user learning data

[1800] What it does: The server retrieves data about the user's past records and preferences from a database.

[1801] Input: User ID or historical material identification.

[1802] Output: Analysis of user's historical data and preferences.

[1803] Data processing / data calculation: The server retrieves the user's past material information from the database and analyzes the data to learn patterns and preferences.

[1804] Step 4:

[1805] emotion recognition

[1806] Specific operation: The server uses the emotion engine to recognize the emotion when the user inputs a request.

[1807] Input: User input and interaction data.

[1808] Output: Data indicating the user's emotional state.

[1809] Data processing / data calculation: The emotion engine analyzes input data and estimates the emotional state.

[1810] Step 5:

[1811] Integrating learning outcomes and emotions

[1812] Specific operation: The server integrates the acquired training data with the emotion recognition results.

[1813] Input: User preference analysis results and emotional state data.

[1814] Output: Planning data for material generation.

[1815] Data processing / data calculation: The server formulates an optimal plan for generating materials, taking into account the user's preferences and emotional state.

[1816] Step 6:

[1817] Automatic chart generation

[1818] Specific operation: The server sends a request to the chart generation API to generate the appropriate chart.

[1819] Input: Planning data for material generation.

[1820] Output: The generated chart data.

[1821] Data processing / data calculation: The chart generation API generates appropriate charts and tables based on the request and returns the data to the server.

[1822] Step 7:

[1823] Editing and formatting materials

[1824] Specific operation: The server places the generated figures and tables into the document template and adjusts the design and layout.

[1825] Input: Generated diagram data and user preference and emotional state data.

[1826] Output: Formatted and edited data.

[1827] Data processing / data calculation: The server places figures and tables on the template and adjusts the layout and design as needed.

[1828] Step 8:

[1829] Material Retention and Notification

[1830] Specific operation: The server converts the completed materials into a document format and stores them in the database.

[1831] Input: Formatted and edited data.

[1832] Output: Document data in document format (e.g. PDF, PPTX) and notification of completion of saving.

[1833] Data processing / data calculation: The server converts the material data into the specified document format and stores it in the database.

[1834] Step 9:

[1835] notification

[1836] Specific operation: The server notifies the user that the document is complete.

[1837] Input: Saved material data.

[1838] Output: A notification message to the user.

[1839] Data processing / data calculation: The server generates a notification message and sends it to the user, including the link and file name of the material.

[1840] Step 10:

[1841] Processing feedback and updating learnings

[1842] Specific operation: The user reviews the generated materials and provides feedback. The server receives the feedback, analyzes it, and updates the learning data.

[1843] Input: User feedback data.

[1844] Output: Updated training data.

[1845] Data processing / data calculation: The server analyzes the feedback, reflects the content in the learning data, and applies it to the next document creation.

[1846] (Application example 2)

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

[1848] In modern factories, many robots are in operation, and managing them requires a great deal of time and effort. Furthermore, the emotions and stress levels of managers often affect the quality of their work. A method is needed to solve these problems and generate efficient, user-friendly robot management reports.

[1849] 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 a user to input a request for document creation; means for analyzing the input request; means for learning based on the user's past documents and preferences; means for planning document creation based on the learning results; means for automatically generating appropriate figures and tables; means for formatting and editing the generated figures and tables; means for saving the generated documents and notifying the user; means for receiving user feedback and updating the learning data; and means for including an emotion recognition engine that recognizes the user's emotional state and adjusting the design and content of the documents according to the emotional state. This enables efficient and high-quality robot management reports to be generated while taking into account the emotional state of the manager.

[1850] The "means for the user to input a request for material creation" refers to an interface through which the user inputs specific requests for material creation using his / her own terminal.

[1851] The "means for analyzing an input request" refers to a software module that analyzes a request input by a user and identifies and classifies the request content.

[1852] "Means for learning based on the user's past materials and preferences" refers to an algorithm that acquires the user's past material data and preference patterns stored in a database and learns from them using a machine learning model.

[1853] "Means for planning the generation of materials based on learning results" refers to a planning module that plans what information to include in the materials and in what format based on learning results.

[1854] "Means for automatically generating appropriate figures and tables" refers to a function that uses a chart generation API based on a plan to automatically generate appropriate figures and tables.

[1855] "Means for formatting and editing the generated figures and tables" refers to software tools that are used to format the generated figures and tables to fit the design and layout of the document and make any necessary edits.

[1856] "Means for saving the generated materials and notifying the user" refers to a communication module that saves the completed materials in a database and notifies the user of the link and file name.

[1857] The "means for receiving user feedback and updating learning data" refers to a control program that receives feedback from users, analyzes the content of the feedback, and updates the learning data.

[1858] "Means for adjusting the design and content of materials according to the emotional state, including an emotion recognition engine" refers to an engine that analyzes the user's emotions and an algorithm that optimizes the design and content of materials according to the emotional state.

[1859] This invention is a system for efficiently managing robot operation data and maintenance information in factory management, thereby reducing the stress of managers. This system is implemented through the following steps.

[1860] System Overview:

[1861] The system receives requests for document creation from users, analyzes them, learns from them, plans them, automatically generates appropriate diagrams and tables, and finally provides them as documents. During this process, it uses an emotion recognition engine to recognize the user's emotional state and optimize the document creation process.

[1862] Hardware and software:

[1863] Smartphone: Used by the user to input requests for material creation.

[1864] Head-mounted display: Used by the user to view the generated materials.

[1865] Emotion recognition engine: Software that analyzes user input and recognizes their emotional state.

[1866] Chart generation API: An API for automatically generating charts and tables based on your requests.

[1867] Databases (e.g., Firebase): Used to store and retrieve user history and preferences.

[1868] Notification Service: A service for notifying users of the link and file name of the completed document.

[1869] Examples:

[1870] When a user wants to create a new robot operation report, they use their smartphone to enter the following request:

[1871] Title: "Robot Operation Report"

[1872] Information included: "Operating time", "Failure rate", "Maintenance history"

[1873] Desired table or graph: "Bar chart", "Pie chart"

[1874] The server analyzes this request and learns from the user's past materials and preferences. It also uses an emotion recognition engine to recognize the user's emotional state (e.g., tension or stress). It then creates a material generation plan that takes into account the learning results and the user's emotional state. Based on this plan, it automatically generates appropriate diagrams and tables using a diagram generation API.

[1875] The generated diagrams and tables are formatted and edited in a design optimized for the user's emotional state and saved as the final document in the database. Once the document is complete, a notification is sent to the user via a notification service. The system is continuously improved as users review the document and provide feedback.

[1876] Example prompt sentence:

[1877] "We understand that users are nervous. Please generate a simple, easy-to-read 'Robot Operation Report' for them. The report should include bar charts and pie charts with uptime, failure rate, and maintenance history."

[1878] In this way, the system can take into account the emotional state of the manager and automatically generate efficient and high-quality robot management reports, thereby reducing the burden of work.

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

[1880] Step 1:

[1881] The user inputs a request for document creation. Using a terminal, the user inputs the document title, the information to be included, the desired type of chart, etc. This input data is sent to the server. The input data includes "robot operation report," "operation time," "failure rate," "maintenance history," "bar chart," "pie chart," etc.

[1882] Step 2:

[1883] The server analyzes the input request. The server analyzes the received request data and identifies the document title, the information to be included, the desired type of chart, etc. The analysis results are stored in an internal data structure. For example, the server identifies "Robot Operation Report" as the title and classifies "Operation Hours," "Failure Rate," and "Maintenance History" as the required information.

[1884] Step 3:

[1885] The server learns based on the user's past data and preferences. The server retrieves the user's past data and design preferences from a database. This data is input into a machine learning algorithm to learn the user's preferences and trends. For example, it analyzes past robot reports and design patterns.

[1886] Step 4:

[1887] The server creates a plan for generating materials based on the learning results. Based on the acquired data and the learned user preferences, it plans what information to include in the materials and in what format. This plan may include, for example, using a bar chart for "operating time" and a pie chart for "failure rate."

[1888] Step 5:

[1889] The server uses an emotion recognition engine to recognize the user's emotional state. It analyzes the user's typing speed and click patterns to estimate their emotional state, such as tension or stress. The results are used to adjust the design and content of the materials.

[1890] Step 6:

[1891] The server automatically generates the appropriate charts and tables. Based on the plan, it sends a request to the chart generation API to generate the necessary charts (bar charts and pie charts). For example, it generates a bar chart using the "uptime" data and a pie chart using the "failure rate" data.

[1892] Step 7:

[1893] The server formats and edits the generated diagrams and tables. It places the generated diagrams and tables into a document template and adjusts the design and layout based on the user's emotional state. For example, if the user is nervous, it will create a simple, easy-to-read layout.

[1894] Step 8:

[1895] The server saves the generated document and notifies the user. The server saves the final document in PDF or PPTX format and notifies the user of the link and file name. The notification includes a download link for the generated document.

[1896] Step 9:

[1897] The user provides feedback. Through the terminal, the user inputs feedback on the generated materials. The feedback includes corrections and improvements.

[1898] Step 10:

[1899] The server analyzes user feedback and updates the learning data. The provided feedback is analyzed and reflected in the next data generation along with the emotion engine data. This allows the system to continuously improve.

[1900] This series of steps enables efficient and high-quality robot management reports to be automatically generated while taking into consideration the user's emotional state.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Claims

1. a means for a user to input a request for material creation; means for analyzing an input request; a means for learning based on a user's past material and preferences; A means for planning the generation of materials based on the learning results; a means of automatically generating appropriate figures and tables; a means for formatting and editing the generated figures and tables; means for storing the generated material and notifying the user; a means for receiving user feedback and updating the learning data; A system including:

2. Also includes means to interface with a chart generation API to generate appropriate charts and tables. The system of claim 1 .

3. It learns user preferences from background information and past data, and further includes the means to personalize materials to suit their preferences. The system of claim 1 .

Images