System

Abstract

A system is provided.SOLUTION: A system comprising: means for receiving a paper file and a posting history from a user; means for analyzing the received paper file and posting history and suggesting an optimal posting destination candidate; means for automatically correcting a format of the paper file in accordance with a definition of the suggested posting destination; means for proofreading the paper file in English; means for analyzing a comment from a reviewer and suggesting an additional experiment plan and a correction point; and means for automatically generating a reply to the reviewer.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] When researchers submit a paper, they must go through a complex process that involves formatting, proofreading, proposing additional experiments, and writing responses to reviewers, which takes a tremendous amount of time and effort. This makes it difficult to quickly resubmit a paper or effectively revise it, significantly hindering the progress of research. This invention aims to significantly reduce the burden on researchers by streamlining these processes, thereby enabling them to quickly resubmit papers. [Means for solving the problem]

[0005] This invention provides a system that includes means for receiving a paper file and submission history from a user, means for analyzing the received paper file and submission history to suggest optimal submission destination candidates, means for automatically correcting the format of the paper file to conform to the specifications of the suggested submission destinations, means for proofreading the English of the paper file, means for analyzing comments from reviewers to suggest additional experimental plans and corrections, and means for automatically generating replies to reviewers.This enables users to efficiently find destinations for resubmission, correct the format of the paper to conform to the specifications of the submission destinations, and quickly respond to reviewer requests.

[0006] A "paper file" is a document in which a user describes research results, and is sent to the server as electronic data.

[0007] "Submission history" refers to information regarding the process of papers being submitted and the review results.

[0008] "Generative AI" is a system that uses artificial intelligence technology to analyze data and generate appropriate actions and suggestions.

[0009] "Possible submission destinations" is a list of scientific journals and academic conferences to which the paper should next be submitted based on the analysis results.

[0010] "Formatting" is the process of changing the format, style, figures, etc. of a manuscript file to conform to the requirements of a specific submission destination.

[0011] "English proofreading" is the process of correcting grammar, terminology, and style to ensure accurate and appropriate English expression in a paper file.

[0012] "Reviewer comments" refers to feedback and requests for revisions from experts reviewing a paper.

[0013] An "additional experiment plan" is a plan for a new experiment proposed based on reviewer comments.

[0014] A "Response" is a document containing the author's response or explanation to a reviewer comment. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0023] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0036] To implement the present invention, it is necessary to configure a system and execute a program as follows.

[0037] System configuration

[0038] server:

[0039] The server contains a generative AI model, a database, a formatting correction module, an English proofreading module, a reviewer comment analysis module, and a response generation module. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the user's device.

[0040] Device:

[0041] The terminal provides an interface where users can upload their paper files, enter their submission history, and check the server's suggestions and corrections. The terminal also supports data communication between the user and the server.

[0042] User:

[0043] As a researcher, users manage the paper submission process through their devices: submitting paper files, selecting potential publication destinations, reviewing and resubmitting revised and proofread papers, and responding to comments from reviewers.

[0044] Program processing explanation

[0045] server:

[0046] 1. Receiving your manuscript and submission history:

[0047] The server stores the submitted paper files and submission history in a database, and the stored data is then analyzed.

[0048] 2. Suggestions for potential publications:

[0049] The server uses the generative AI model to analyze the content of the paper and its submission history, compiles a list of suitable submission candidates, and sends it to the user's device.

[0050] 3. Formatting corrections:

[0051] When a user selects a submission destination, the server retrieves the formatting specifications of that destination and automatically converts the paper file into the specified format.

[0052] 4. English Proofreading:

[0053] The English proofreading module on the server checks the corrected format of the paper file for appropriate grammar, style, and terminology, and makes any necessary corrections.

[0054] 5. Reviewer Comment Analysis:

[0055] When a user resubmits or reviews a review, they send the reviewer comments they received to the server, which then uses a comment analysis module to suggest additional experiment plans or corrections.

[0056] 6. Response Generation:

[0057] The server automatically generates a response based on the reviewer's comments and sends it to the user, who then checks and edits it before sending it back to the reviewer.

[0058] Device:

[0059] 1. Data Entry:

[0060] Users upload their paper files and enter their submission history through their terminals, which then send this data to the server.

[0061] 2. Check potential publications:

[0062] The candidate posting destinations sent from the server are displayed on the terminal, and the user selects the most suitable posting destination.

[0063] 3. Download the fix:

[0064] Users will be able to download papers that have been formatted and proofread through their terminals.

[0065] 4. Provide reviewer comments:

[0066] After reposting, the user sends the comments received from the reviewer from the terminal to the server.

[0067] 5. Check the response:

[0068] The response sent from the server is displayed on the terminal, and the user checks and corrects it before sending it to the reviewer.

[0069] Specific examples

[0070] When Dr. A submits "sample_paper.pdf" to the server, the server receives the paper and its submission history and begins analysis. Based on the paper's content and past submission history, the generative AI model suggests "Journal A," "Journal B," and "Journal C" as possible publication destinations. Dr. A reviews this on his device and selects "Journal A." The server then edits "sample_paper.pdf" in accordance with Journal A's formatting specifications and scrutinizes the text using the English proofreading module. The server then provides the revised paper to Dr. A for resubmission. After resubmission, Dr. A receives comments from reviewers and sends them to the server, which then proposes additional experimental plans and creates responses to the reviewers using the response generation module. In this way, Dr. A can quickly and efficiently resubmit or revise his paper.

[0071] The processing flow will be explained below.

[0072] Step 1:

[0073] Users upload their paper files and enter their submission history using their terminals. Once the data is complete, it is sent to the server.

[0074] Step 2:

[0075] The server receives the paper files and submission history sent by the user and stores this data in a database. After storing it, it prepares it for analysis.

[0076] Step 3:

[0077] The server uses the generated AI model to analyze the contents of the paper file and the submission history. Based on the analysis results, it creates a list of optimal submission candidates and sends it to the user's device.

[0078] Step 4:

[0079] The terminal displays the list of candidate posting destinations sent from the server, and provides an interface that allows the user to check this list.

[0080] Step 5:

[0081] The user checks the list of possible posting destinations on the device and selects the most suitable destination. The selected information is sent to the server.

[0082] Step 6:

[0083] The server retrieves the formatting requirements of the submission destination selected by the user from the database, automatically corrects the format of the paper file to conform to those requirements, generates the corrected file, and sends it to the user's device.

[0084] Step 7:

[0085] The terminal displays the formatted paper file sent from the server and provides the user with a downloadable link.

[0086] Step 8:

[0087] The user downloads the corrected formatted paper and checks its contents.

[0088] Step 9:

[0089] The server then runs the revised paper file through the English proofreading module, checking for appropriate grammar, style, and terminology, making any necessary corrections, and generates a proofread file that is sent to the user's device.

[0090] Step 10:

[0091] The terminal displays the proofread paper for the user to review and download.

[0092] Step 11:

[0093] The user checks the edited paper and resubmits it.

[0094] Step 12:

[0095] The user inputs the comments received from the reviewer after reposting into the terminal and transmits them to the server.

[0096] Step 13:

[0097] The server receives the reviewer comments, analyzes them using the generation AI, proposes necessary additional experiment plans and corrections, and sends the results to the user's device.

[0098] Step 14:

[0099] The terminal displays the additional experiment plan and modifications sent from the server, and provides an interface for the user to check them.

[0100] Step 15:

[0101] The user checks the proposal and makes any necessary corrections or additional experiments.

[0102] Step 16:

[0103] The server automatically generates a response based on the reviewer's comments and sends it to the user's device, allowing the user to check, modify, and submit the response.

[0104] Step 17:

[0105] The user checks and edits the response and sends it to the reviewer.

[0106] In this way, the system supports users in efficiently resubmitting papers and responding to reviewers.

[0107] Example 1

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

[0109] Traditionally, the paper submission process required researchers to manually perform a wide range of tasks, including selecting a journal to submit to, formatting, proofreading, and responding to reviewer comments, which required a great deal of time and effort. The process of selecting a journal and formatting was particularly complex and prone to errors. It was also difficult to find an appropriate response to reviewer comments. To solve these issues, an automated system is needed.

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

[0111] In this invention, the server includes means for receiving a paper file and submission history from a user, means for analyzing the received paper file and submission history and using a generative AI model to suggest optimal submission destination candidates, means for automatically correcting the format of the paper file to conform to the specifications of the suggested submission destinations, means for proofreading the corrected paper file, means for analyzing reviewer comments received by the user after resubmission and suggesting additional experimental plans and corrections, and means for automatically generating replies to reviewers. This streamlines the paper submission process, reduces the workload on researchers, and improves the success rate of submissions.

[0112] A "paper file" refers to a document that summarizes research results and considerations submitted by a user, and is saved in a format such as a PDF or text file.

[0113] "Submission history" refers to information that records the journals to which a user has submitted papers, the results, and the feedback they received.

[0114] A "generative AI model" refers to an algorithm that uses artificial intelligence to analyze user input data and suggest potential posting destinations.

[0115] "Formatting" refers to the process of automatically adjusting page layout, fonts, citation style, etc. of a paper file in accordance with the specified submission guidelines.

[0116] "Proofreading" refers to the process of checking and correcting English grammar, style, and vocabulary for accuracy.

[0117] "Reviewer comments" refers to the feedback and evaluation provided by a journal's reviewers on a paper.

[0118] "Additional experimental plan" refers to a plan for experiments or research activities that should be added to the paper, suggested based on reviewer comments.

[0119] "Revisions" refer to the parts or content in the paper that need to be revised based on reviewer comments.

[0120] A "response" refers to a text that summarizes a user's response or rebuttal to a comment received from a reviewer.

[0121] To implement the present invention, it is necessary to configure a system and execute a program as follows.

[0122] System configuration

[0123] server:

[0124] The server contains a generative AI model, a database, a formatting correction module, an English proofreading module, a reviewer comment analysis module, and a response generation module. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the users' devices.

[0125] Device:

[0126] The terminal provides an interface for users to upload paper files, enter their submission history, and check the server's suggestions and corrections. The terminal also supports data communication between the user and the server.

[0127] User:

[0128] As a researcher, users manage the paper submission process through their devices: submitting paper files, selecting potential publication destinations, reviewing and resubmitting revised and proofread papers, and responding to comments from reviewers.

[0129] Program processing explanation

[0130] server:

[0131] The server stores the submitted paper files and submission history in a database, which is then analyzed by a generative AI model.

[0132] The server uses a generative AI model to analyze the content of the paper and its submission history, compiles a list of suitable submission candidates, and sends it to the user's device.

[0133] When a user selects a submission destination, the server retrieves the formatting specifications of that destination and automatically converts the paper file into the corresponding format.

[0134] The English proofreading module on the server checks the corrected paper file for appropriate grammar, style, and terminology, and makes any necessary corrections.

[0135] When a user resubmits or reviews a review, the reviewer comments received are sent to the server, where they are analyzed using a comment analysis module, which then proposes additional experimental plans and corrections.

[0136] The server automatically generates a response based on the reviewer's comments and sends it to the user, who then checks and corrects it and sends it back to the reviewer.

[0137] Device:

[0138] Users upload their paper files and enter their submission history via their terminals, and this data is sent to the server.

[0139] The candidate posting destinations sent from the server are displayed on the terminal, and the user selects the most suitable posting destination.

[0140] The terminal provides the paper with formatting correction and English proofreading completed so that the user can download the corrected paper.

[0141] After reposting, the user sends the comments received from the reviewer from the terminal to the server.

[0142] The response sent from the server is displayed on the terminal, and the user checks and corrects it before sending it to the reviewer.

[0143] Specific examples

[0144] When Dr. A submits "sample_paper.pdf" to the server via his / her device, the server receives the paper file and submission history and stores them in a database. Next, it uses a generative AI model to analyze the paper content and submission history, suggesting potential publication destinations such as "Journal A," "Journal B," and "Journal C." This information is then sent to the user's device. When Dr. A selects "Journal A" on his / her device, the server modifies "sample_paper.pdf" based on the formatting specifications of that publication. The English proofreading module then checks grammar and style and makes any necessary corrections. The revised paper is then provided to the user's device, where Dr. A can review and resubmit it. After resubmission, Dr. A receives comments from the reviewers and sends them from his / her device to the server. The server analyzes the comments and suggests additional experimental plans and revisions. The response generation module then generates a response to the reviewer and sends it to Dr. A. Dr. A reviews and edits the response and finally sends it to the reviewer.

[0145] Prompt Sentence Examples

[0146] "Please explain how the server formats the paper."

[0147] "Please explain specifically how to use a generative AI model to suggest potential posting destinations."

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

[0149] Step 1:

[0150] The user uses the terminal to upload the paper file (e.g., "sample_paper.pdf") and submission history. This becomes the input data. The terminal then sends this data to the server. Specifically, the system transfers the file specified by the user to the server using the system's upload function.

[0151] Step 2:

[0152] The server receives the paper file and submission history data sent from the terminal and stores them in a database. This data becomes input data. The specific operations performed by the server include storing the received file in the appropriate table in the database and, if necessary, verifying the integrity of the data.

[0153] Step 3:

[0154] The server uses a generative AI model to analyze the saved paper files and submission history. The input data are the saved paper files and submission history. As a result of the analysis, the server generates a list of suitable submission candidates (e.g., "Journal A," "Journal B," "Journal C"), which becomes the output. Specifically, the generative AI model analyzes the content of the uploaded paper based on the content and past submission history, and then recommends appropriate journals.

[0155] Step 4:

[0156] The server sends the generated list of candidate destinations to the user's terminal. The input data is the generated list of candidate destinations, and the output is the data sent to the user's terminal. Specifically, the server performs a data transfer process to notify the user's terminal of an appropriate list of candidate destinations.

[0157] Step 5:

[0158] The user checks the list of suggested posting destinations on the device and selects the most suitable posting destination from among them (e.g., "Journal A"). The input data is the list of candidate posting destinations, and the output is the selected posting destination. Specifically, the user operates the device interface to perform operations such as clicking a selection button.

[0159] Step 6:

[0160] The server obtains the journal specifications selected by the user and automatically formats the paper file accordingly. The input data is the selected journal and the original paper file, and the output is the formatted paper file. Specifically, the server obtains the format specifications of the journal and automatically adjusts the uploaded paper to comply with those specifications.

[0161] Step 7:

[0162] The server applies the English proofreading module to the paper file after formatting correction is complete. The input data is the paper file after formatting correction, and the output is the proofread paper file. Specifically, the English proofreading module checks the appropriateness of grammar and vocabulary and makes any necessary corrections.

[0163] Step 8:

[0164] The server sends the proofread paper file to the user's terminal. The input data is the proofread paper file, and the output is the revised paper file sent to the terminal. Specifically, the server performs data communication processing to transfer the proofread paper file to the user's terminal.

[0165] Step 9:

[0166] The user checks the revised paper file on their device and resubmits it. The input data is the proofread paper file, and the output is the resubmitted paper file. Specifically, the user checks the revised text on their device and then goes through the process of resubmitting it to the journal's submission site.

[0167] Step 10:

[0168] The user sends the reviewer comments received after reposting from the terminal to the server. The input data is the reviewer comments, and the output is the reviewer comments sent to the server. Specifically, the user uploads a file of review comments and sends it to the server.

[0169] Step 11:

[0170] The server uses a reviewer comment analysis module to analyze the received comments and propose additional experiment plans and modifications. The input data are reviewer comments, and the output is proposals as the analysis results. Specifically, the comment analysis module analyzes the comment content and lists recommended experiment plans and modifications.

[0171] Step 12:

[0172] The server automatically generates a response based on the reviewer's comments and sends it to the user. The input data is the analyzed reviewer's comments, and the output is the generated response. Specifically, the response generation module automatically creates an appropriate response based on the analysis results and sends it to the terminal.

[0173] Step 13:

[0174] The user checks and corrects the response on the device and sends it to the reviewer. The input data is the generated response, and the output is the corrected response. Specifically, the user checks the response on the device, makes any necessary corrections, and then sends it to the reviewer.

[0175] (Application example 1)

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

[0177] Currently, quality control processes in factories require a lot of manual work and time, resulting in problems such as reduced efficiency and the risk of human error. Furthermore, analyzing feedback and proposing improvement measures relies on experience and expertise, which can lead to a lack of consistency. Therefore, there is a need to automate and streamline these processes.

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

[0179] In this invention, the server includes means for receiving a paper file and submission history from a user, means for analyzing the received paper file and submission history to suggest optimal submission destination candidates, means for automatically correcting the format of the paper file to conform to the specifications of the suggested submission destination, means for proofreading the paper file, means for analyzing comments from reviewers to suggest additional experiment plans and corrections, means for automatically generating a quality control report, means for automatically correcting the generated report to a specified format, means for analyzing feedback and identifying areas for improvement, means for proposing improvement measures based on the areas for improvement, and means for automatically generating a response to the reviewer. This automates the quality control process within the factory, enabling efficient and consistent analysis of feedback and proposal of improvement measures.

[0180] "User" means a person or organization that uses the system to manage the manuscript submission process and quality control process.

[0181] A "paper file" is a digital document of an academic paper written by a researcher.

[0182] A "submission history" is a record of which journals and academic publications a researcher has submitted papers to in the past.

[0183] "Analysis" is the process of converting input data into meaningful information.

[0184] The "best publication candidates" are a list of academic journals and journals suitable for submitting a paper, suggested based on the analysis results.

[0185] "Formatting" is the process of automatically changing the format of a paper file according to certain rules.

[0186] "English proofreading" is the process of checking English texts for appropriate grammar, style, and terminology, and making any necessary corrections.

[0187] "Reviewer comments" are evaluations and feedback given by reviewers of a paper on its content.

[0188] "Additional Experiment Plan" is a plan for additional experiments that are proposed based on reviewer comments.

[0189] "Revisions" are the specific changes needed to improve the paper based on reviewer comments.

[0190] A "response" is a written response or reply made by a researcher to a reviewer's comment.

[0191] A "quality control report" is a document that organizes data on product quality within a factory and reports on the quality status.

[0192] "Feedback" refers to evaluations and comments received from superiors, quality control departments, etc.

[0193] "Improvements" are specific areas for improving a product or process that are identified based on feedback.

[0194] "Improvements" are proposed ways to improve a product or process based on improvements.

[0195] To implement this invention, it is necessary to configure the following system and run the program. The main components of the system are a server, a terminal, and a user. This invention is designed specifically to streamline the quality control process in factories.

[0196] System configuration

[0197] server

[0198] The server contains a generative AI model, a database, a formatting correction module, an English proofreading module, a feedback analysis module, and a module for suggesting improvements. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the terminal.

[0199] Terminal

[0200] The terminal provides an interface for users to upload quality control reports, input feedback, and view suggestions and corrections from the server. The terminal supports data communication between the user and the server.

[0201] User

[0202] As a quality control officer at a factory, the user manages the quality control process through the terminal, submitting quality control reports, inputting feedback, and confirming and implementing corrections and improvements.

[0203] Program processing explanation

[0204] server

[0205] The server stores the quality control reports and feedback received from the devices in a database. A generative AI model automatically generates quality control reports based on data collected from sensors and inspection equipment. During this process, the stored data is analyzed. AI models used include GPT-3 and SpellChecker.

[0206] The server has a format correction module that automatically corrects the generated report into a specified format. If the corrected report is in English, the English proofreading module checks the appropriateness of grammar, style, and terminology and makes any necessary corrections.

[0207] The feedback analysis module analyzes the feedback provided by users and identifies specific areas for improvement. Based on these results, the improvement proposal module generates specific improvement measures and provides them to users. This allows users to efficiently identify and implement improvements to their quality control.

[0208] Terminal

[0209] The terminal provides an interface for users to upload quality control reports and enter feedback. The terminal transmits this data to the server, where the user can check the correction results and improvement suggestions sent by the server. The terminal also makes the generated quality control reports and suggested improvements available for download.

[0210] Specific examples

[0211] For example, suppose a quality control officer at a factory submits a file called "sensor_data.csv" to the server. The server receives the data and uses a generative AI model to automatically generate a quality control report. At that time, the server specifies the format "quality control report" and automatically corrects the format.

[0212] When a user sends feedback received from their superior to the server from their device, the feedback analysis module begins analysis to identify specific areas for improvement. Then, using a generative AI model, it proposes appropriate improvement measures, enabling the person in charge to quickly and efficiently improve their quality control process.

[0213] Prompt Sentence Examples

[0214] "Generate a quality control report based on the data from the sensors in the following format:

[0215] Data Overview

[0216] Problem

[0217] Current measures

[0218] Recommended Improvements

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

[0220] Step 1:

[0221] The user uploads quality control reports and feedback via the terminal and sends them to the server. The input data is the quality control report (e.g., "sensor_data.csv") and feedback, and data is transmitted from the terminal to the server. The output is the uploaded data stored in the server's database.

[0222] Step 2:

[0223] The server stores the received quality control reports in a database. This stored data is then used for analysis. Specifically, the server inserts the data into the database in the appropriate format. The input is the uploaded quality control report data, and the output is the data already stored in the database.

[0224] Step 3:

[0225] The server uses a generative AI model (e.g., GPT-3) to automatically generate a report based on the stored quality control report data. During this process, a prompt is input into the generative AI model, which generates text based on the required data. The input is the quality control report data and the prompt, and the output is the generated quality control report text. An example of a specific prompt is, "Based on data from the sensors, please generate a quality control report in the following format: - Data summary - Problem - Current measures - Recommended improvement measures."

[0226] Step 4:

[0227] The server automatically modifies the generated quality control report to the specified format. It uses a format modification module to convert the data to fit the required layout and format. The input is the generated quality control report text and formatting specifications, and the output is the modified report. Specifically, it adjusts the layout and adds the necessary headers and footers.

[0228] Step 5:

[0229] If the corrected report is in English, the server's English proofreading module checks the grammar, style, and terminology for appropriateness and makes any necessary corrections. The input is the corrected English report, and the output is the proofread report. Specifically, grammar checks and style guide-based corrections are made.

[0230] Step 6:

[0231] The user sends the feedback received from the superior or quality control department from the terminal to the server. The feedback data is used as input, and the server takes the feedback stored in the database. The output is the saved feedback data.

[0232] Step 7:

[0233] The server's feedback analysis module analyzes the feedback provided by users and identifies areas for improvement. The input is the feedback data, and the output is the identified areas for improvement. Specific operations include analyzing the feedback text and performing automatic scoring and keyword extraction.

[0234] Step 8:

[0235] Based on the analysis results, the server's improvement suggestion module generates specific improvement suggestions and provides them to the user. The suggestion text is automatically generated using a generative AI model (e.g., GPT-3). The input is the analysis results and a prompt text, and the output is a suggested improvement text. An example of a specific prompt text is, "Please suggest specific improvement measures based on the feedback below."

[0236] Step 9:

[0237] The user checks the improvement proposals sent from the server on their terminal and implements them as necessary. The input is the improvement proposal, and the output is an executable action plan. Specifically, the process includes the actions of checking the proposals and formulating an implementation plan.

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

[0239] To implement the present invention, it is necessary to configure a system and execute a program as follows.

[0240] System configuration

[0241] server:

[0242] The server contains a generative AI model, database, formatting correction module, English proofreading module, reviewer comment analysis module, response generation module, and emotion engine. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the user's device.

[0243] Device:

[0244] The terminal provides an interface where users can upload their paper files, enter their submission history, and check the server's suggestions and corrections. The terminal also supports data communication between the user and the server. Furthermore, the terminal also provides an interface with emotion recognition functionality for analyzing the user's emotional state.

[0245] User:

[0246] As a researcher, users manage the paper submission process through their devices: they submit paper files, select potential publication destinations, review and resubmit revised and proofread papers, respond to reviewers' comments, and communicate their emotional state to the system through emotion recognition.

[0247] Program processing explanation

[0248] server:

[0249] 1. Receiving your manuscript and submission history:

[0250] The server stores the submitted paper files and submission history in a database, and then prepares them for analysis.

[0251] 2. Suggestions for potential publications:

[0252] The server uses a generative AI model to analyze the content of the paper and the submission history, and then creates a list of suitable submission candidates and sends it to the user's device. The emotion engine recognizes the user's emotional state and adjusts the suggestions accordingly.

[0253] 3. Formatting corrections:

[0254] Once a user selects a submission destination, the server retrieves the destination's formatting requirements and automatically converts the manuscript file into the specified format. An emotional engine adjusts the tone and style of the formatting based on the user's emotional state.

[0255] 4. English Proofreading:

[0256] The server-based English proofreading module checks the formatted manuscript file for appropriate grammar, style, and terminology, and makes any necessary corrections. The emotional engine adjusts the tone and style of the proofreading based on the user's emotional state.

[0257] 5. Reviewer Comment Analysis:

[0258] When a user resubmits or reviews a piece of content, they send the reviewer comments they received to the server, which then uses a comment analysis module to suggest additional experiment plans or corrections. The emotion engine adjusts the suggestions based on the user's emotional state.

[0259] 6. Response Generation:

[0260] The server automatically generates a response based on the reviewer's comments and sends it to the user. The emotion engine adjusts the tone and style of the response based on the user's emotional state. The user can then review and edit the response before sending it to the reviewer.

[0261] Device:

[0262] 1. Data Entry:

[0263] Users upload their paper files and enter their submission history through their terminals, which then send this data to the server.

[0264] 2. Check potential publications:

[0265] The server sends a list of potential posting destinations to the device, and the user selects the most appropriate one. The emotion recognition function analyzes the user's emotional state and sends the results to the server.

[0266] 3. Download the fix:

[0267] Users will be able to download papers that have been formatted and proofread through their terminals.

[0268] 4. Provide reviewer comments:

[0269] After reposting, the user sends the comments received from the reviewer from their device to the server, where the emotion recognition function analyzes the user's emotional state and sends it to the server.

[0270] 5. Check the response:

[0271] The response sent from the server is displayed on the device, and the user can check and edit it before sending it to the reviewer. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0272] Specific examples

[0273] When Dr. A submits "sample_paper.pdf" to the server, the server receives the paper and its submission history and begins analysis. Based on the paper's content and past submission history, the generative AI model suggests "Journal A," "Journal B," and "Journal C" as possible submission destinations. The emotion engine analyzes the user's stress level and, if stress levels are high, emphasizes the suggestion of "Journal B," which has a faster review process. Dr. A confirms this on his device and selects "Journal A." The server then edits "sample_paper.pdf" according to "Journal A's" formatting specifications, and the emotion engine adjusts the tone and style of the formatting based on the user's stress level. The English proofreading module then examines grammar, style, and terminology, and the emotion engine adjusts the tone and style accordingly. The revised paper is then provided to Dr. A for resubmission. After resubmission, Dr. A receives comments from reviewers and sends them to the server, which then proposes additional experimental plans and creates a response to the reviewers using the response generation module. The emotion engine adjusts the tone of suggestions and responses based on the user's emotional state, allowing Dr. A to quickly and efficiently resubmit or revise his paper.

[0274] The processing flow will be explained below.

[0275] Step 1:

[0276] The user uploads the paper file using a terminal and enters the submission history. Once the input is complete, the data is sent to the server by pressing the send button.

[0277] Step 2:

[0278] The server receives the submitted paper files and submission history from users and stores this data in a database. After storing the data, it begins preparation for analysis.

[0279] Step 3:

[0280] The server uses the generated AI model to analyze the content of the paper file and the submission history. At the same time, the emotion engine analyzes the user's emotional state data obtained from the device. This allows it to create a list of optimal submission candidates and adjust the suggestions according to the user's emotional state.

[0281] Step 4:

[0282] The server sends a list of suggested posting destinations to the user's device, with the list containing candidates prioritized based on the user's emotional state.

[0283] Step 5:

[0284] The terminal displays a list of candidate posting destinations sent from the server, and provides an interface that allows the user to review the list and select the most suitable posting destination.

[0285] Step 6:

[0286] The user checks the list of potential posting destinations on the device and selects the most suitable one. After selection, the selection information is sent to the server.

[0287] Step 7:

[0288] The server retrieves the formatting requirements of the user's chosen submission destination from a database and automatically formats the manuscript file to conform to those requirements. An emotional engine adjusts the tone and style of the formatting based on the user's emotional state.

[0289] Step 8:

[0290] The server generates a formatted paper file and sends it to the user's terminal.

[0291] Step 9:

[0292] The terminal displays the formatted paper file sent from the server and provides the user with a downloadable link.

[0293] Step 10:

[0294] The user downloads the corrected formatted paper and checks its contents.

[0295] Step 11:

[0296] The server runs the revised paper file through an English proofreading module, checking for appropriate grammar, style, and terminology and making any necessary corrections. An emotional engine adjusts the tone and style of the proofreading based on the user's emotional state.

[0297] Step 12:

[0298] The server generates a proofread paper file and sends it to the user's device.

[0299] Step 13:

[0300] The device will display the proofread paper and provide a link for the user to view and download.

[0301] Step 14:

[0302] The user reviews the proofread paper and, if they determine that no revisions are necessary, resubmits the paper. After resubmission, they receive comments from reviewers.

[0303] Step 15:

[0304] The user inputs the comments received from the reviewer into the device and sends them to the server. The emotion recognition function analyzes the user's emotional state and sends that data to the server.

[0305] Step 16:

[0306] The server receives reviewer comments, analyzes them using generative AI and an emotion engine, and sends them to the user, proposing additional experiment plans and modifications based on the user's emotional state.

[0307] Step 17:

[0308] The terminal displays the additional experiment plan and corrections sent from the server. The user checks this and performs any necessary corrections or additional experiments.

[0309] Step 18:

[0310] The server automatically generates a response based on the reviewer's comments and sends it to the user's device, adjusting the tone and style of the response based on the user's emotional state.

[0311] Step 19:

[0312] The device displays the response sent from the server, and the user can check and correct it before sending it to the reviewer.

[0313] In this way, the system helps users efficiently resubmit their manuscripts and respond to reviewers, and it also adjusts suggestions, formatting, proofreading, and responses taking into account the user's emotional state.

[0314] Example 2

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

[0316] Researchers face a wide range of challenges in the process of submitting academic papers. These include gathering information to select the appropriate publication, the complexity of submission formats, the burden of proofreading, and writing appropriate responses to reviewer comments. These tasks require time and effort, which increases researchers' stress. Furthermore, the impact of researchers' emotional state on these processes cannot be ignored. Conventional systems do not provide comprehensive solutions to these challenges.

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

[0318] In this invention, the server includes means for receiving a research result file and history information from a user, means for analyzing the received research result file and history information to suggest optimal candidate submission destinations, means for automatically correcting the format of the research result file to conform to the specifications of the suggested submission destinations, means for translating and correcting the research result file, means for analyzing comments from evaluators to suggest additional experimental plans and corrections, means for automatically generating responses to the evaluators, and means for analyzing the user's emotional state using an emotion analysis engine and adjusting the tone and style of each process, thereby enabling users to complete the paper submission process quickly and efficiently and reducing their mental burden.

[0319] "User" refers to the researcher or contributor who uses this system and is responsible for uploading research result files, selecting the submission destination, and responding to reviewer comments.

[0320] "Research result files" refer to academic papers and research reports uploaded to this system, and are documents that are subject to formatting correction and translation proofreading.

[0321] "History information" refers to information on past submission history and accepted papers, and is information that serves as reference data when proposing potential next submission destinations.

[0322] "Server" refers to a computer system that analyzes data received from users, suggests suitable submission candidates, and automatically performs formatting corrections and translation proofreading.

[0323] "Candidate submission destinations" refers to the most suitable academic journals or academic societies to which the paper should be submitted, as suggested by the server after analyzing the research results file and historical information.

[0324] "Format correction" refers to the act of automatically changing the format of a research results file in accordance with the regulations of the potential recipient.

[0325] "Translation correction" refers to the process of checking research files for appropriate grammar, style, and terminology and making any necessary corrections.

[0326] "Evaluator opinions" refer to comments and feedback provided by reviewers during the paper review process that may require additional experimental design or suggested revisions.

[0327] "Additional experimental plans" refer to plans for new experiments or surveys proposed based on the evaluator's opinions.

[0328] A "response" refers to a piece of writing written in response to the evaluator's comments, and includes revisions to the paper and supplementary explanations.

[0329] "Emotion analysis engine" refers to artificial intelligence that analyzes the user's emotional state and adjusts the tone and style of each interaction.

[0330] In order to implement the present invention, it is necessary to configure the following system and execute the program.

[0331] System configuration

[0332] server:

[0333] The server contains a generative AI model, database, format correction module, translation correction module, evaluator opinion analysis module, response generation module, and sentiment analysis engine. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the user's device.

[0334] Device:

[0335] The terminal provides an interface where users can upload research files, input history information, and check suggestions and corrections from the server. The terminal also supports data communication between the user and the server. It also provides an interface with emotion recognition functionality to analyze the user's emotional state.

[0336] User:

[0337] As a researcher, users manage the process of submitting research files through their devices. Specifically, they submit research files, select potential recipients, review and resubmit revised and proofread files, respond to comments from reviewers, and communicate their emotional state to the system through emotion recognition.

[0338] Program processing explanation

[0339] server:

[0340] 1. Receiving thesis and historical information:

[0341] The server stores the research result files and history information sent by users in a database, and then prepares them for analysis.

[0342] 2. Suggestions for potential recipients:

[0343] The server uses a generative AI model to analyze the content and history of research file files, and lists suitable submission candidates. An emotion analysis engine recognizes the user's emotional state and adjusts the suggestions accordingly.

[0344] 3. Format correction:

[0345] Once a user selects a submission destination, the server retrieves the destination's specifications and automatically formats the research file into the specified format. A sentiment analysis engine adjusts the tone and style of the format based on the user's emotional state.

[0346] 4. Translation corrections:

[0347] The server's translation correction module checks the formatted research file for appropriate grammar, style, and terminology, and makes any necessary corrections. The sentiment analysis engine adjusts the tone and style of the corrections based on the user's emotional state.

[0348] 5. Analysis of evaluator opinions:

[0349] When a user resubmits or reviews a review, the user sends the evaluator's comments to the server, which uses the opinion analysis module to suggest additional experiment plans or modifications. The sentiment analysis engine adjusts the suggestions based on the user's emotional state.

[0350] 6. Response Generation:

[0351] The server automatically generates a response based on the evaluator's opinion and sends it to the user. The sentiment analysis engine adjusts the tone and style of the response based on the user's emotional state. The user then checks and edits the response and sends it back to the evaluator.

[0352] Device:

[0353] 1. Data Entry:

[0354] Users upload research result files and enter history information through their terminals, which then send this data to the server.

[0355] 2. Confirm potential recipients:

[0356] The server sends a list of possible submission destinations to the user, which are then displayed on the device, allowing the user to select the most appropriate one. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0357] 3. Download the fix:

[0358] Users will be able to download research result files that have been formatted and translated via their terminals.

[0359] 4. Providing reviewer feedback:

[0360] After reposting, the user sends the feedback received from the reviewers from their device to the server. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0361] 5. Check the response:

[0362] The response sent from the server is displayed on the device, and the user confirms and corrects it before sending it to the evaluator. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0363] Specific operation example

[0364] When a researcher submits "sample_paper.pdf" to the server, the server begins analyzing the research results file and history information. The generative AI model analyzes the contents of the research results file and, based on past history information, suggests possible submission destinations such as "Journal A," "Journal B," and "Journal C." The sentiment analysis engine analyzes the user's emotional state and, for example, if stress is high, emphasizes the suggestion of "Journal B," which has a quick review process. The researcher confirms this on their device and selects "Journal A."

[0365] The server then edits "sample_paper.pdf" according to the formatting specifications of "Journal A," and a sentiment analysis engine adjusts the tone and style of the format based on the user's stress level. The translation correction module then examines grammar, style, and terminology, and the sentiment analysis engine adjusts the tone and style. The revised research output file is then provided to the researcher, who is then encouraged to resubmit.

[0366] After resubmitting, researchers receive comments from evaluators and send them to the server. The server then uses a comment analysis module to propose additional experimental plans and a response generation module to create a response to the evaluators. An emotion analysis engine adjusts the content of the proposal and the tone of the response based on the user's emotional state. In this way, researchers can quickly and efficiently resubmit their research results and respond to evaluator comments.

[0367] Examples of prompts:

[0368] Please explain the process of a researcher submitting a research result file to a server. Please also explain the process of the server accepting the research result file, analyzing it, suggesting suitable submission destinations, and correcting the format and translation based on emotion recognition. Also, please explain the process of generating a response to a comment.

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

[0370] Step 1:

[0371] Receiving papers and historical information

[0372] Input: The user uses the terminal to upload the research output file (e.g., "sample_paper.pdf") and history information (e.g., past submission history).

[0373] Specific operation: The terminal receives the research result file and history information provided by the user and transmits this data to the server.

[0374] Output: The server stores the received data in a database.

[0375] Step 2:

[0376] Suggestions for potential recipients

[0377] Input: Research output files and historical information stored in the server's database.

[0378] How it works: The server uses generative AI models to analyze the content and history of research files, for example, using topic modeling to identify research topics and then lists the best candidates for submission.

[0379] Output: Sends suggested submission candidates (e.g. "Journal A", "Journal B", "Journal C") to the user's device.

[0380] Step 3:

[0381] Format correction

[0382] Input: The submission destination selected by the user (e.g. "Journal A").

[0383] What it does: When a user selects a submission destination, the server retrieves the destination's formatting requirements and automatically formats the research file according to the specified format (e.g., font, paragraph style, citation format, etc.). The sentiment analysis engine adjusts the tone and style of the format based on the user's emotional state.

[0384] Output: Research results file in modified format.

[0385] Step 4:

[0386] Translation fixes

[0387] Input: Research results file in modified format.

[0388] What it does: The server uses a translation correction module to check for appropriate grammar, style, and terminology and make any necessary corrections. The sentiment analysis engine adjusts tone and style based on the user's emotional state.

[0389] Output: Research results file with translation correction completed.

[0390] Step 5:

[0391] Download the fixed version

[0392] Input: Research results file with translation corrections completed.

[0393] Specific operation: The server is configured to provide the modified research result file to the user's terminal, and the user can download the file from the terminal.

[0394] Output: The modified research file downloaded by the user.

[0395] Step 6:

[0396] Providing evaluator opinions

[0397] Input: Input received from reviewers after resubmission (e.g., comments and feedback).

[0398] Specific operation: The user sends the evaluator's opinion from the device to the server. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0399] Output: Rater opinions and user emotional state data sent to the server.

[0400] Step 7:

[0401] Analysis of evaluator opinions

[0402] Input: Rater opinions and user emotional state data sent to the server.

[0403] Specific operation: The server uses the opinion analysis module to analyze the evaluator's opinions. Based on this, it proposes additional experiment plans and modifications. The sentiment analysis engine adjusts the proposals based on the user's emotional state.

[0404] Output: Suggested additional experimental designs and modifications.

[0405] Step 8:

[0406] Response Generation

[0407] Input: Additional experimental design and modifications based on the reviewer's comments.

[0408] How it works: The server uses a response generation module to automatically generate responses for the evaluator. The sentiment analysis engine adjusts the tone and style of the responses based on the user's emotional state.

[0409] Output: The response sent to the user.

[0410] Step 9:

[0411] Check the response

[0412] Input: The response sent by the server.

[0413] Specific operation: The user checks the response on the device, corrects it if necessary, and sends it to the evaluator. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0414] Output: Modified response sentences and user emotional state data.

[0415] (Application example 2)

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

[0417] Evaluating security policies and audit reports requires specialized knowledge, time, and effort. Human error and incompleteness in the evaluation process can affect the accuracy of risk assessments. Furthermore, proposing security measures and responding to reviewer comments must be done efficiently and quickly, but these processes require advanced knowledge and experience, making them difficult for many companies. Therefore, there is a need for a system that automates security evaluations, reduces the burden on users, and performs highly accurate risk assessments.

[0418] The identification process by the identification 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 receiving a document file and inspection history from a user, means for analyzing the received document file and inspection history to propose optimal candidate evaluation sites, means for automatically correcting the format of the document file in accordance with the specifications of the proposed evaluation sites, means for grammar proofreading the document file, means for analyzing comments from reviewers to propose additional inspection plans and corrections, means for automatically generating a response to the reviewer, and means for analyzing the reviewer's emotional state to adjust the tone and style of the suggestions and the response. This automates the evaluation of security policies and audit reports, reducing the user's burden and enabling efficient and rapid, highly accurate risk assessment.

[0419] A "document file" is a text document that is the subject of evaluation, such as a security policy or an audit report.

[0420] "Inspection history" refers to records of past audits and security inspections and the resulting data.

[0421] "Evaluation candidates" are candidates for organizations or systems that are proposed as targets for which document files should be evaluated.

[0422] "Format correction" is the process of automatically formatting and adjusting a document file to conform to the specifications of the proposed evaluation site.

[0423] "Grammar proofreading" is the process of checking the grammar, style, and terminology in a document and making any necessary corrections.

[0424] "Reviewer comments" are feedback or suggestions provided by the reviewer of a document file.

[0425] "Additional Inspection Plan" is a plan for additional security inspections or evaluations proposed based on reviewer comments.

[0426] "Modifications" are proposed changes or adjustments to the document file or security policy based on reviewer comments.

[0427] A "response" is a text that contains a response or rebuttal to a reviewer's comment.

[0428] "Emotional state" refers to a psychological state that indicates a user's stress level and emotional changes.

[0429] "Tone and style" refers to the way a document or response is presented or worded, and is adjusted according to the user's emotional state.

[0430] In order to implement the present invention, it is necessary to configure a security evaluation system and execute the following programs.

[0431] System configuration

[0432] server:

[0433] The server contains a generative AI model, database, formatting correction module, grammar proofreading module, reviewer comment analysis module, response generation module, and emotion engine. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the users' devices.

[0434] Device:

[0435] The terminal provides an interface where users can upload document files, input inspection history, and check suggestions and correction results from the server. The terminal also supports data communication between the user and the server. It also provides an interface with emotion recognition functionality to analyze the user's emotional state.

[0436] User:

[0437] As a company security officer, users manage the evaluation process of security policies and audit reports through their terminals. Specifically, they submit document files, select candidates for evaluation, review and resubmit corrected and proofread documents, respond to comments from reviewers, and communicate their emotional state to the system through emotion recognition.

[0438] Program processing explanation

[0439] server:

[0440] 1. Receiving document files and inspection history:

[0441] The server stores the document files and inspection history sent by the user in a database, and then prepares them for analysis.

[0442] 2. Suggestion of candidate evaluation sites:

[0443] The server uses a generative AI model to analyze the document file and inspection history, and then lists appropriate evaluation candidates and sends them to the user's device. The emotion engine recognizes the user's emotional state and adjusts the suggestions accordingly.

[0444] 3. Formatting corrections:

[0445] When a user selects a rating destination, the server retrieves the rating destination's formatting specifications and automatically converts the document file into the specified format. The emotional engine adjusts the tone and style of the format based on the user's emotional state.

[0446] 4. Grammar proofreading:

[0447] The server-based grammar correction module checks the formatted document file for appropriate grammar, style, and terminology, and makes any necessary corrections. The emotion engine adjusts the tone and style of the correction based on the user's emotional state.

[0448] 5. Reviewer Comment Analysis:

[0449] When a user resubmits or receives reviewer comments after review, the server uses a comment analysis module to suggest additional inspection plans and corrections. The emotion engine adjusts the suggestions based on the user's emotional state.

[0450] 6. Response Generation:

[0451] The server automatically generates a response based on the reviewer's comments and sends it to the user. The emotion engine adjusts the tone and style of the response based on the user's emotional state. The user can then review and edit the response before sending it to the reviewer.

[0452] Device:

[0453] 1. Data Entry:

[0454] Users upload document files and enter inspection history through their terminals, which then send this data to the server.

[0455] 2. Confirmation of potential evaluation targets:

[0456] The server sends a list of potential rating recipients to the user's device, and the user selects the most appropriate one. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0457] 3. Download the fix:

[0458] The user can download the document that has been formatted and grammar corrected through the terminal.

[0459] 4. Provide reviewer comments:

[0460] After resubmission, the user sends the comments received from the reviewer from their device to the server, where the emotion recognition function analyzes the user's emotional state and sends the results to the server.

[0461] 5. Check the response:

[0462] The response sent from the server is displayed on the device, and the user can check and edit it before sending it to the reviewer. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0463] Specific examples

[0464] When a company's security officer submits "Security Policy.pdf" to the server, the server receives the document and its inspection history and begins analysis. Based on the document's content and past inspection history, the generative AI model suggests "Assessment Agency A," "Assessment Agency B," and "Assessment Agency C" as potential evaluation candidates. The emotion engine analyzes the user's stress level and, if stress levels are high, emphasizes the suggestion of "Assessment Agency B," which has a faster evaluation process. The officer reviews this on their device and selects "Assessment Agency A." The server then modifies "Security Policy.pdf" according to the formatting specifications of "Assessment Agency A," and the emotion engine adjusts the tone and style of the formatting based on the user's stress level. The grammar proofreading module then scrutinizes grammar, style, and terminology, and the emotion engine adjusts the tone and style. The revised document is provided to the officer for resubmission. After resubmission, the officer receives comments from the reviewers and sends them to the server, which proposes additional inspection plans and creates a response to the reviewer using the response generation module. The emotion engine adjusts the suggestion content and tone of the response based on the user's emotional state. In this way, personnel can quickly and efficiently evaluate and revise security policies.

[0465] Example prompts for generative AI models

[0466] "Analyze the security audit report and answer the following questions:

[0467] 1. Which of the security measures you have implemented are weak? Which areas need improvement?

[0468] 2. What are the recommended measures to address the identified risks?

[0469] 3. What message should you convey to users? Tailor your suggestions to them, especially considering their stress levels.

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

[0471] Step 1:

[0472] The user uses a terminal to upload a document file (e.g., "SecurityPolicy.pdf") and inspection history. The terminal sends this data to the server. The server receives the document file and inspection history and stores them in a database. The input data is the document file and inspection history, and the output data is a notification that the data has been successfully saved to the database.

[0473] Step 2:

[0474] The server uses a generative AI model to analyze the saved document file and inspection history. The input data is the document file and inspection history, and the output data is the analysis results, which are evaluation destination candidates (e.g., "Evaluation Agency A," "Evaluation Agency B," "Evaluation Agency C"). The generative AI model analyzes the document content and performs the process of suggesting the most suitable evaluation destination.

[0475] Step 3:

[0476] The server uses an emotion engine to analyze the user's emotional state at the time of upload. The input data for emotion recognition is the user's facial expressions and voice data, and the output data is the analyzed emotional state (e.g., stress level). The suggestions are adjusted based on the analysis results.

[0477] Step 4:

[0478] The server sends the candidate evaluation destinations to the terminal. The terminal displays them to the user, who selects the most suitable evaluation destination. Information on the selected evaluation destination is sent to the server. The input data is the candidate evaluation destinations, and the output data is the selected evaluation destination.

[0479] Step 5:

[0480] The server obtains the format specification of the selected evaluation target and automatically converts the document file to the specified format. The input data is the document file and the format specification, and the output data is the document file after formatting correction. The server uses the format correction module to adjust the tone and style based on the emotion engine.

[0481] Step 6:

[0482] The server uses a grammar correction module to check the formatted document file for appropriate grammar, style, and terminology, and makes any necessary corrections. The input data is the formatted document file, and the output data is the grammar-corrected document file. The emotion engine adjusts the tone and style of the proofreading. The proofread document file is then sent to the terminal, ready for the user to download.

[0483] Step 7:

[0484] The user uses a terminal to check the document file after formatting and grammar correction has been completed and resubmit it. The server receives the resubmitted document file along with the reviewer comments. The input data is the document file and the reviewer comments, and the output data is a notification of successful upload to the server.

[0485] Step 8:

[0486] The server uses the reviewer comment analysis module to analyze the reviewer comments and propose additional inspection plans and corrections. The input data is the reviewer comments, and the output data is the proposed additional inspection plans and corrections. The analysis results are sent to the terminal and displayed to the user.

[0487] Step 9:

[0488] The server uses a response generation module to automatically generate responses based on reviewer comments. The input data is the reviewer comments, and the output data is the generated response. The emotion engine adjusts the tone and style of the response. The generated response is sent to the device, where the user can review and edit it.

[0489] Step 10:

[0490] The user uses a terminal to check the generated response, make any necessary corrections, and send it to the reviewer. The input data is the generated response and any user corrections, and the output data is the final response. This process allows the user to efficiently evaluate security policies and audit reports and respond to reviewer comments.

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

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

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

[0494] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0507] To implement the present invention, it is necessary to configure a system and execute a program as follows.

[0508] System configuration

[0509] server:

[0510] The server contains a generative AI model, a database, a formatting correction module, an English proofreading module, a reviewer comment analysis module, and a response generation module. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the user's device.

[0511] Device:

[0512] The terminal provides an interface where users can upload their paper files, enter their submission history, and check the server's suggestions and corrections. The terminal also supports data communication between the user and the server.

[0513] User:

[0514] As a researcher, users manage the paper submission process through their devices: submitting paper files, selecting potential publication destinations, reviewing and resubmitting revised and proofread papers, and responding to comments from reviewers.

[0515] Program processing explanation

[0516] server:

[0517] 1. Receiving your manuscript and submission history:

[0518] The server stores the submitted paper files and submission history in a database, and the stored data is then analyzed.

[0519] 2. Suggestions for potential publications:

[0520] The server uses the generative AI model to analyze the content of the paper and its submission history, compiles a list of suitable submission candidates, and sends it to the user's device.

[0521] 3. Formatting corrections:

[0522] When a user selects a submission destination, the server retrieves the formatting specifications of that destination and automatically converts the paper file into the specified format.

[0523] 4. English Proofreading:

[0524] The English proofreading module on the server checks the corrected format of the paper file for appropriate grammar, style, and terminology, and makes any necessary corrections.

[0525] 5. Reviewer Comment Analysis:

[0526] When a user resubmits or reviews a review, they send the reviewer comments they received to the server, which then uses a comment analysis module to suggest additional experiment plans or corrections.

[0527] 6. Response Generation:

[0528] The server automatically generates a response based on the reviewer's comments and sends it to the user, who then checks and edits it before sending it back to the reviewer.

[0529] Device:

[0530] 1. Data Entry:

[0531] Users upload their paper files and enter their submission history through their terminals, which then send this data to the server.

[0532] 2. Check potential publications:

[0533] The candidate posting destinations sent from the server are displayed on the terminal, and the user selects the most suitable posting destination.

[0534] 3. Download the fix:

[0535] Users will be able to download papers that have been formatted and proofread through their terminals.

[0536] 4. Provide reviewer comments:

[0537] After reposting, the user sends the comments received from the reviewer from the terminal to the server.

[0538] 5. Check the response:

[0539] The response sent from the server is displayed on the terminal, and the user checks and corrects it before sending it to the reviewer.

[0540] Specific examples

[0541] When Dr. A submits "sample_paper.pdf" to the server, the server receives the paper and its submission history and begins analysis. Based on the paper's content and past submission history, the generative AI model suggests "Journal A," "Journal B," and "Journal C" as possible publication destinations. Dr. A reviews this on his device and selects "Journal A." The server then edits "sample_paper.pdf" in accordance with Journal A's formatting specifications and scrutinizes the text using the English proofreading module. The server then provides the revised paper to Dr. A for resubmission. After resubmission, Dr. A receives comments from reviewers and sends them to the server, which then proposes additional experimental plans and creates responses to the reviewers using the response generation module. In this way, Dr. A can quickly and efficiently resubmit or revise his paper.

[0542] The processing flow will be explained below.

[0543] Step 1:

[0544] Users upload their paper files and enter their submission history using their terminals. Once the data is complete, it is sent to the server.

[0545] Step 2:

[0546] The server receives the paper files and submission history sent by the user and stores this data in a database. After storing it, it prepares it for analysis.

[0547] Step 3:

[0548] The server uses the generated AI model to analyze the contents of the paper file and the submission history. Based on the analysis results, it creates a list of optimal submission candidates and sends it to the user's device.

[0549] Step 4:

[0550] The terminal displays the list of candidate posting destinations sent from the server, and provides an interface that allows the user to check this list.

[0551] Step 5:

[0552] The user checks the list of possible posting destinations on the device and selects the most suitable destination. The selected information is sent to the server.

[0553] Step 6:

[0554] The server retrieves the formatting requirements of the submission destination selected by the user from the database, automatically corrects the format of the paper file to conform to those requirements, generates the corrected file, and sends it to the user's device.

[0555] Step 7:

[0556] The terminal displays the formatted paper file sent from the server and provides the user with a downloadable link.

[0557] Step 8:

[0558] The user downloads the corrected formatted paper and checks its contents.

[0559] Step 9:

[0560] The server then runs the revised paper file through the English proofreading module, checking for appropriate grammar, style, and terminology, making any necessary corrections, and generates a proofread file that is sent to the user's device.

[0561] Step 10:

[0562] The terminal displays the proofread paper for the user to review and download.

[0563] Step 11:

[0564] The user checks the edited paper and resubmits it.

[0565] Step 12:

[0566] The user inputs the comments received from the reviewer after reposting into the terminal and transmits them to the server.

[0567] Step 13:

[0568] The server receives the reviewer comments, analyzes them using the generation AI, proposes necessary additional experiment plans and corrections, and sends the results to the user's device.

[0569] Step 14:

[0570] The terminal displays the additional experiment plan and modifications sent from the server, and provides an interface for the user to check them.

[0571] Step 15:

[0572] The user checks the proposal and makes any necessary corrections or additional experiments.

[0573] Step 16:

[0574] The server automatically generates a response based on the reviewer's comments and sends it to the user's device, allowing the user to check, modify, and submit the response.

[0575] Step 17:

[0576] The user checks and edits the response and sends it to the reviewer.

[0577] In this way, the system supports users in efficiently resubmitting papers and responding to reviewers.

[0578] Example 1

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

[0580] Traditionally, the paper submission process required researchers to manually perform a wide range of tasks, including selecting a journal to submit to, formatting, proofreading, and responding to reviewer comments, which required a great deal of time and effort. The process of selecting a journal and formatting was particularly complex and prone to errors. It was also difficult to find an appropriate response to reviewer comments. To solve these issues, an automated system is needed.

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

[0582] In this invention, the server includes means for receiving a paper file and submission history from a user, means for analyzing the received paper file and submission history and using a generative AI model to suggest optimal submission destination candidates, means for automatically correcting the format of the paper file to conform to the specifications of the suggested submission destinations, means for proofreading the corrected paper file, means for analyzing reviewer comments received by the user after resubmission and suggesting additional experimental plans and corrections, and means for automatically generating replies to reviewers. This streamlines the paper submission process, reduces the workload on researchers, and improves the success rate of submissions.

[0583] A "paper file" refers to a document that summarizes research results and considerations submitted by a user, and is saved in a format such as a PDF or text file.

[0584] "Submission history" refers to information that records the journals to which a user has submitted papers, the results, and the feedback they received.

[0585] A "generative AI model" refers to an algorithm that uses artificial intelligence to analyze user input data and suggest potential posting destinations.

[0586] "Formatting" refers to the process of automatically adjusting page layout, fonts, citation style, etc. of a paper file in accordance with the specified submission guidelines.

[0587] "Proofreading" refers to the process of checking and correcting English grammar, style, and vocabulary for accuracy.

[0588] "Reviewer comments" refers to the feedback and evaluation provided by a journal's reviewers on a paper.

[0589] "Additional experimental plan" refers to a plan for experiments or research activities that should be added to the paper, suggested based on reviewer comments.

[0590] "Revisions" refer to the parts or content in the paper that need to be revised based on reviewer comments.

[0591] A "response" refers to a text that summarizes a user's response or rebuttal to a comment received from a reviewer.

[0592] To implement the present invention, it is necessary to configure a system and execute a program as follows.

[0593] System configuration

[0594] server:

[0595] The server contains a generative AI model, a database, a formatting correction module, an English proofreading module, a reviewer comment analysis module, and a response generation module. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the users' devices.

[0596] Device:

[0597] The terminal provides an interface for users to upload paper files, enter their submission history, and check the server's suggestions and corrections. The terminal also supports data communication between the user and the server.

[0598] User:

[0599] As a researcher, users manage the paper submission process through their devices: submitting paper files, selecting potential publication destinations, reviewing and resubmitting revised and proofread papers, and responding to comments from reviewers.

[0600] Program processing explanation

[0601] server:

[0602] The server stores the submitted paper files and submission history in a database, which is then analyzed by a generative AI model.

[0603] The server uses a generative AI model to analyze the content of the paper and its submission history, compiles a list of suitable submission candidates, and sends it to the user's device.

[0604] When a user selects a submission destination, the server retrieves the formatting specifications of that destination and automatically converts the paper file into the corresponding format.

[0605] The English proofreading module on the server checks the corrected paper file for appropriate grammar, style, and terminology, and makes any necessary corrections.

[0606] When a user resubmits or reviews a review, the reviewer comments received are sent to the server, where they are analyzed using a comment analysis module, which then proposes additional experimental plans and corrections.

[0607] The server automatically generates a response based on the reviewer's comments and sends it to the user, who then checks and corrects it and sends it back to the reviewer.

[0608] Device:

[0609] Users upload their paper files and enter their submission history via their terminals, and this data is sent to the server.

[0610] The candidate posting destinations sent from the server are displayed on the terminal, and the user selects the most suitable posting destination.

[0611] The terminal provides the paper with formatting correction and English proofreading completed so that the user can download the corrected paper.

[0612] After reposting, the user sends the comments received from the reviewer from the terminal to the server.

[0613] The response sent from the server is displayed on the terminal, and the user checks and corrects it before sending it to the reviewer.

[0614] Specific examples

[0615] When Dr. A submits "sample_paper.pdf" to the server via his / her device, the server receives the paper file and submission history and stores them in a database. Next, it uses a generative AI model to analyze the paper content and submission history, suggesting potential publication destinations such as "Journal A," "Journal B," and "Journal C." This information is then sent to the user's device. When Dr. A selects "Journal A" on his / her device, the server modifies "sample_paper.pdf" based on the formatting specifications of that publication. The English proofreading module then checks grammar and style and makes any necessary corrections. The revised paper is then provided to the user's device, where Dr. A can review and resubmit it. After resubmission, Dr. A receives comments from the reviewers and sends them from his / her device to the server. The server analyzes the comments and suggests additional experimental plans and revisions. The response generation module then generates a response to the reviewer and sends it to Dr. A. Dr. A reviews and edits the response and finally sends it to the reviewer.

[0616] Prompt Sentence Examples

[0617] "Please explain how the server formats the paper."

[0618] "Please explain specifically how to use a generative AI model to suggest potential posting destinations."

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

[0620] Step 1:

[0621] The user uses the terminal to upload the paper file (e.g., "sample_paper.pdf") and submission history. This becomes the input data. The terminal then sends this data to the server. Specifically, the system transfers the file specified by the user to the server using the system's upload function.

[0622] Step 2:

[0623] The server receives the paper file and submission history data sent from the terminal and stores them in a database. This data becomes input data. The specific operations performed by the server include storing the received file in the appropriate table in the database and, if necessary, verifying the integrity of the data.

[0624] Step 3:

[0625] The server uses a generative AI model to analyze the saved paper files and submission history. The input data are the saved paper files and submission history. As a result of the analysis, the server generates a list of suitable submission candidates (e.g., "Journal A," "Journal B," "Journal C"), which becomes the output. Specifically, the generative AI model analyzes the content of the uploaded paper based on the content and past submission history, and then recommends appropriate journals.

[0626] Step 4:

[0627] The server sends the generated list of candidate destinations to the user's terminal. The input data is the generated list of candidate destinations, and the output is the data sent to the user's terminal. Specifically, the server performs a data transfer process to notify the user's terminal of an appropriate list of candidate destinations.

[0628] Step 5:

[0629] The user checks the list of suggested posting destinations on the device and selects the most suitable posting destination from among them (e.g., "Journal A"). The input data is the list of candidate posting destinations, and the output is the selected posting destination. Specifically, the user operates the device interface to perform operations such as clicking a selection button.

[0630] Step 6:

[0631] The server obtains the journal specifications selected by the user and automatically formats the paper file accordingly. The input data is the selected journal and the original paper file, and the output is the formatted paper file. Specifically, the server obtains the format specifications of the journal and automatically adjusts the uploaded paper to comply with those specifications.

[0632] Step 7:

[0633] The server applies the English proofreading module to the paper file after formatting correction is complete. The input data is the paper file after formatting correction, and the output is the proofread paper file. Specifically, the English proofreading module checks the appropriateness of grammar and vocabulary and makes any necessary corrections.

[0634] Step 8:

[0635] The server sends the proofread paper file to the user's terminal. The input data is the proofread paper file, and the output is the revised paper file sent to the terminal. Specifically, the server performs data communication processing to transfer the proofread paper file to the user's terminal.

[0636] Step 9:

[0637] The user checks the revised paper file on their device and resubmits it. The input data is the proofread paper file, and the output is the resubmitted paper file. Specifically, the user checks the revised text on their device and then goes through the process of resubmitting it to the journal's submission site.

[0638] Step 10:

[0639] The user sends the reviewer comments received after reposting from the terminal to the server. The input data is the reviewer comments, and the output is the reviewer comments sent to the server. Specifically, the user uploads a file of review comments and sends it to the server.

[0640] Step 11:

[0641] The server uses a reviewer comment analysis module to analyze the received comments and propose additional experiment plans and modifications. The input data are reviewer comments, and the output is proposals as the analysis results. Specifically, the comment analysis module analyzes the comment content and lists recommended experiment plans and modifications.

[0642] Step 12:

[0643] The server automatically generates a response based on the reviewer's comments and sends it to the user. The input data is the analyzed reviewer's comments, and the output is the generated response. Specifically, the response generation module automatically creates an appropriate response based on the analysis results and sends it to the terminal.

[0644] Step 13:

[0645] The user checks and corrects the response on the device and sends it to the reviewer. The input data is the generated response, and the output is the corrected response. Specifically, the user checks the response on the device, makes any necessary corrections, and then sends it to the reviewer.

[0646] (Application example 1)

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

[0648] Currently, quality control processes in factories require a lot of manual work and time, resulting in problems such as reduced efficiency and the risk of human error. Furthermore, analyzing feedback and proposing improvement measures relies on experience and expertise, which can lead to a lack of consistency. Therefore, there is a need to automate and streamline these processes.

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

[0650] In this invention, the server includes means for receiving a paper file and submission history from a user, means for analyzing the received paper file and submission history to suggest optimal submission destination candidates, means for automatically correcting the format of the paper file to conform to the specifications of the suggested submission destination, means for proofreading the paper file, means for analyzing comments from reviewers to suggest additional experiment plans and corrections, means for automatically generating a quality control report, means for automatically correcting the generated report to a specified format, means for analyzing feedback and identifying areas for improvement, means for proposing improvement measures based on the areas for improvement, and means for automatically generating a response to the reviewer. This automates the quality control process within the factory, enabling efficient and consistent analysis of feedback and proposal of improvement measures.

[0651] "User" means a person or organization that uses the system to manage the manuscript submission process and quality control process.

[0652] A "paper file" is a digital document of an academic paper written by a researcher.

[0653] A "submission history" is a record of which journals and academic publications a researcher has submitted papers to in the past.

[0654] "Analysis" is the process of converting input data into meaningful information.

[0655] The "best publication candidates" are a list of academic journals and journals suitable for submitting a paper, suggested based on the analysis results.

[0656] "Formatting" is the process of automatically changing the format of a paper file according to certain rules.

[0657] "English proofreading" is the process of checking English texts for appropriate grammar, style, and terminology, and making any necessary corrections.

[0658] "Reviewer comments" are evaluations and feedback given by reviewers of a paper on its content.

[0659] "Additional Experiment Plan" is a plan for additional experiments that are proposed based on reviewer comments.

[0660] "Revisions" are the specific changes needed to improve the paper based on reviewer comments.

[0661] A "response" is a written response or reply made by a researcher to a reviewer's comment.

[0662] A "quality control report" is a document that organizes data on product quality within a factory and reports on the quality status.

[0663] "Feedback" refers to evaluations and comments received from superiors, quality control departments, etc.

[0664] "Improvements" are specific areas for improving a product or process that are identified based on feedback.

[0665] "Improvements" are proposed ways to improve a product or process based on improvements.

[0666] To implement this invention, it is necessary to configure the following system and run the program. The main components of the system are a server, a terminal, and a user. This invention is designed specifically to streamline the quality control process in factories.

[0667] System configuration

[0668] server

[0669] The server contains a generative AI model, a database, a formatting correction module, an English proofreading module, a feedback analysis module, and a module for suggesting improvements. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the terminal.

[0670] Terminal

[0671] The terminal provides an interface for users to upload quality control reports, input feedback, and view suggestions and corrections from the server. The terminal supports data communication between the user and the server.

[0672] User

[0673] As a quality control officer at a factory, the user manages the quality control process through the terminal, submitting quality control reports, inputting feedback, and confirming and implementing corrections and improvements.

[0674] Program processing explanation

[0675] server

[0676] The server stores the quality control reports and feedback received from the devices in a database. A generative AI model automatically generates quality control reports based on data collected from sensors and inspection equipment. During this process, the stored data is analyzed. AI models used include GPT-3 and SpellChecker.

[0677] The server has a format correction module that automatically corrects the generated report into a specified format. If the corrected report is in English, the English proofreading module checks the appropriateness of grammar, style, and terminology and makes any necessary corrections.

[0678] The feedback analysis module analyzes the feedback provided by users and identifies specific areas for improvement. Based on these results, the improvement proposal module generates specific improvement measures and provides them to users. This allows users to efficiently identify and implement improvements to their quality control.

[0679] Terminal

[0680] The terminal provides an interface for users to upload quality control reports and enter feedback. The terminal transmits this data to the server, where the user can check the correction results and improvement suggestions sent by the server. The terminal also makes the generated quality control reports and suggested improvements available for download.

[0681] Specific examples

[0682] For example, suppose a quality control officer at a factory submits a file called "sensor_data.csv" to the server. The server receives the data and uses a generative AI model to automatically generate a quality control report. At that time, the server specifies the format "quality control report" and automatically corrects the format.

[0683] When a user sends feedback received from their superior to the server from their device, the feedback analysis module begins analysis to identify specific areas for improvement. Then, using a generative AI model, it proposes appropriate improvement measures, enabling the person in charge to quickly and efficiently improve their quality control process.

[0684] Prompt Sentence Examples

[0685] "Generate a quality control report based on the data from the sensors in the following format:

[0686] Data Overview

[0687] Problem

[0688] Current measures

[0689] Recommended Improvements

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

[0691] Step 1:

[0692] The user uploads quality control reports and feedback via the terminal and sends them to the server. The input data is the quality control report (e.g., "sensor_data.csv") and feedback, and data is transmitted from the terminal to the server. The output is the uploaded data stored in the server's database.

[0693] Step 2:

[0694] The server stores the received quality control reports in a database. This stored data is then used for analysis. Specifically, the server inserts the data into the database in the appropriate format. The input is the uploaded quality control report data, and the output is the data already stored in the database.

[0695] Step 3:

[0696] The server uses a generative AI model (e.g., GPT-3) to automatically generate a report based on the stored quality control report data. During this process, a prompt is input into the generative AI model, which generates text based on the required data. The input is the quality control report data and the prompt, and the output is the generated quality control report text. An example of a specific prompt is, "Based on data from the sensors, please generate a quality control report in the following format: - Data summary - Problem - Current measures - Recommended improvement measures."

[0697] Step 4:

[0698] The server automatically modifies the generated quality control report to the specified format. It uses a format modification module to convert the data to fit the required layout and format. The input is the generated quality control report text and formatting specifications, and the output is the modified report. Specifically, it adjusts the layout and adds the necessary headers and footers.

[0699] Step 5:

[0700] If the corrected report is in English, the server's English proofreading module checks the grammar, style, and terminology for appropriateness and makes any necessary corrections. The input is the corrected English report, and the output is the proofread report. Specifically, grammar checks and style guide-based corrections are made.

[0701] Step 6:

[0702] The user sends the feedback received from the superior or quality control department from the terminal to the server. The feedback data is used as input, and the server takes the feedback stored in the database. The output is the saved feedback data.

[0703] Step 7:

[0704] The server's feedback analysis module analyzes the feedback provided by users and identifies areas for improvement. The input is the feedback data, and the output is the identified areas for improvement. Specific operations include analyzing the feedback text and performing automatic scoring and keyword extraction.

[0705] Step 8:

[0706] Based on the analysis results, the server's improvement suggestion module generates specific improvement suggestions and provides them to the user. The suggestion text is automatically generated using a generative AI model (e.g., GPT-3). The input is the analysis results and a prompt text, and the output is a suggested improvement text. An example of a specific prompt text is, "Please suggest specific improvement measures based on the feedback below."

[0707] Step 9:

[0708] The user checks the improvement proposals sent from the server on their terminal and implements them as necessary. The input is the improvement proposal, and the output is an executable action plan. Specifically, the process includes the actions of checking the proposals and formulating an implementation plan.

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

[0710] To implement the present invention, it is necessary to configure a system and execute a program as follows.

[0711] System configuration

[0712] server:

[0713] The server contains a generative AI model, database, formatting correction module, English proofreading module, reviewer comment analysis module, response generation module, and emotion engine. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the user's device.

[0714] Device:

[0715] The terminal provides an interface where users can upload their paper files, enter their submission history, and check the server's suggestions and corrections. The terminal also supports data communication between the user and the server. Furthermore, the terminal also provides an interface with emotion recognition functionality for analyzing the user's emotional state.

[0716] User:

[0717] As a researcher, users manage the paper submission process through their devices: they submit paper files, select potential publication destinations, review and resubmit revised and proofread papers, respond to reviewers' comments, and communicate their emotional state to the system through emotion recognition.

[0718] Program processing explanation

[0719] server:

[0720] 1. Receiving your manuscript and submission history:

[0721] The server stores the submitted paper files and submission history in a database, and then prepares them for analysis.

[0722] 2. Suggestions for potential publications:

[0723] The server uses a generative AI model to analyze the content of the paper and the submission history, and then creates a list of suitable submission candidates and sends it to the user's device. The emotion engine recognizes the user's emotional state and adjusts the suggestions accordingly.

[0724] 3. Formatting corrections:

[0725] Once a user selects a submission destination, the server retrieves the destination's formatting requirements and automatically converts the manuscript file into the specified format. An emotional engine adjusts the tone and style of the formatting based on the user's emotional state.

[0726] 4. English Proofreading:

[0727] The server-based English proofreading module checks the formatted manuscript file for appropriate grammar, style, and terminology, and makes any necessary corrections. The emotional engine adjusts the tone and style of the proofreading based on the user's emotional state.

[0728] 5. Reviewer Comment Analysis:

[0729] When a user resubmits or reviews a piece of content, they send the reviewer comments they received to the server, which then uses a comment analysis module to suggest additional experiment plans or corrections. The emotion engine adjusts the suggestions based on the user's emotional state.

[0730] 6. Response Generation:

[0731] The server automatically generates a response based on the reviewer's comments and sends it to the user. The emotion engine adjusts the tone and style of the response based on the user's emotional state. The user can then review and edit the response before sending it to the reviewer.

[0732] Device:

[0733] 1. Data Entry:

[0734] Users upload their paper files and enter their submission history through their terminals, which then send this data to the server.

[0735] 2. Check potential publications:

[0736] The server sends a list of potential posting destinations to the device, and the user selects the most appropriate one. The emotion recognition function analyzes the user's emotional state and sends the results to the server.

[0737] 3. Download the fix:

[0738] Users will be able to download papers that have been formatted and proofread through their terminals.

[0739] 4. Provide reviewer comments:

[0740] After reposting, the user sends the comments received from the reviewer from their device to the server, where the emotion recognition function analyzes the user's emotional state and sends it to the server.

[0741] 5. Check the response:

[0742] The response sent from the server is displayed on the device, and the user can check and edit it before sending it to the reviewer. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0743] Specific examples

[0744] When Dr. A submits "sample_paper.pdf" to the server, the server receives the paper and its submission history and begins analysis. Based on the paper's content and past submission history, the generative AI model suggests "Journal A," "Journal B," and "Journal C" as possible submission destinations. The emotion engine analyzes the user's stress level and, if stress levels are high, emphasizes the suggestion of "Journal B," which has a faster review process. Dr. A confirms this on his device and selects "Journal A." The server then edits "sample_paper.pdf" according to "Journal A's" formatting specifications, and the emotion engine adjusts the tone and style of the formatting based on the user's stress level. The English proofreading module then examines grammar, style, and terminology, and the emotion engine adjusts the tone and style accordingly. The revised paper is then provided to Dr. A for resubmission. After resubmission, Dr. A receives comments from reviewers and sends them to the server, which then proposes additional experimental plans and creates a response to the reviewers using the response generation module. The emotion engine adjusts the tone of suggestions and responses based on the user's emotional state, allowing Dr. A to quickly and efficiently resubmit or revise his paper.

[0745] The processing flow will be explained below.

[0746] Step 1:

[0747] The user uploads the paper file using a terminal and enters the submission history. Once the input is complete, the data is sent to the server by pressing the send button.

[0748] Step 2:

[0749] The server receives the submitted paper files and submission history from users and stores this data in a database. After storing the data, it begins preparation for analysis.

[0750] Step 3:

[0751] The server uses the generated AI model to analyze the content of the paper file and the submission history. At the same time, the emotion engine analyzes the user's emotional state data obtained from the device. This allows it to create a list of optimal submission candidates and adjust the suggestions according to the user's emotional state.

[0752] Step 4:

[0753] The server sends a list of suggested posting destinations to the user's device, with the list containing candidates prioritized based on the user's emotional state.

[0754] Step 5:

[0755] The terminal displays a list of candidate posting destinations sent from the server, and provides an interface that allows the user to review the list and select the most suitable posting destination.

[0756] Step 6:

[0757] The user checks the list of potential posting destinations on the device and selects the most suitable one. After selection, the selection information is sent to the server.

[0758] Step 7:

[0759] The server retrieves the formatting requirements of the user's chosen submission destination from a database and automatically formats the manuscript file to conform to those requirements. An emotional engine adjusts the tone and style of the formatting based on the user's emotional state.

[0760] Step 8:

[0761] The server generates a formatted paper file and sends it to the user's terminal.

[0762] Step 9:

[0763] The terminal displays the formatted paper file sent from the server and provides the user with a downloadable link.

[0764] Step 10:

[0765] The user downloads the corrected formatted paper and checks its contents.

[0766] Step 11:

[0767] The server runs the revised paper file through an English proofreading module, checking for appropriate grammar, style, and terminology and making any necessary corrections. An emotional engine adjusts the tone and style of the proofreading based on the user's emotional state.

[0768] Step 12:

[0769] The server generates a proofread paper file and sends it to the user's device.

[0770] Step 13:

[0771] The device will display the proofread paper and provide a link for the user to view and download.

[0772] Step 14:

[0773] The user reviews the proofread paper and, if they determine that no revisions are necessary, resubmits the paper. After resubmission, they receive comments from reviewers.

[0774] Step 15:

[0775] The user inputs the comments received from the reviewer into the device and sends them to the server. The emotion recognition function analyzes the user's emotional state and sends that data to the server.

[0776] Step 16:

[0777] The server receives reviewer comments, analyzes them using generative AI and an emotion engine, and sends them to the user, proposing additional experiment plans and modifications based on the user's emotional state.

[0778] Step 17:

[0779] The terminal displays the additional experiment plan and corrections sent from the server. The user checks this and performs any necessary corrections or additional experiments.

[0780] Step 18:

[0781] The server automatically generates a response based on the reviewer's comments and sends it to the user's device, adjusting the tone and style of the response based on the user's emotional state.

[0782] Step 19:

[0783] The device displays the response sent from the server, and the user can check and correct it before sending it to the reviewer.

[0784] In this way, the system helps users efficiently resubmit their manuscripts and respond to reviewers, and it also adjusts suggestions, formatting, proofreading, and responses taking into account the user's emotional state.

[0785] Example 2

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

[0787] Researchers face a wide range of challenges in the process of submitting academic papers. These include gathering information to select the appropriate publication, the complexity of submission formats, the burden of proofreading, and writing appropriate responses to reviewer comments. These tasks require time and effort, which increases researchers' stress. Furthermore, the impact of researchers' emotional state on these processes cannot be ignored. Conventional systems do not provide comprehensive solutions to these challenges.

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

[0789] In this invention, the server includes means for receiving a research result file and history information from a user, means for analyzing the received research result file and history information to suggest optimal candidate submission destinations, means for automatically correcting the format of the research result file to conform to the specifications of the suggested submission destinations, means for translating and correcting the research result file, means for analyzing comments from evaluators to suggest additional experimental plans and corrections, means for automatically generating responses to the evaluators, and means for analyzing the user's emotional state using an emotion analysis engine and adjusting the tone and style of each process, thereby enabling users to complete the paper submission process quickly and efficiently and reducing their mental burden.

[0790] "User" refers to the researcher or contributor who uses this system and is responsible for uploading research result files, selecting the submission destination, and responding to reviewer comments.

[0791] "Research result files" refer to academic papers and research reports uploaded to this system, and are documents that are subject to formatting correction and translation proofreading.

[0792] "History information" refers to information on past submission history and accepted papers, and is information that serves as reference data when proposing potential next submission destinations.

[0793] "Server" refers to a computer system that analyzes data received from users, suggests suitable submission candidates, and automatically performs formatting corrections and translation proofreading.

[0794] "Candidate submission destinations" refers to the most suitable academic journals or academic societies to which the paper should be submitted, as suggested by the server after analyzing the research results file and historical information.

[0795] "Format correction" refers to the act of automatically changing the format of a research results file in accordance with the regulations of the potential recipient.

[0796] "Translation correction" refers to the process of checking research files for appropriate grammar, style, and terminology and making any necessary corrections.

[0797] "Evaluator opinions" refer to comments and feedback provided by reviewers during the paper review process that may require additional experimental design or suggested revisions.

[0798] "Additional experimental plans" refer to plans for new experiments or surveys proposed based on the evaluator's opinions.

[0799] A "response" refers to a piece of writing written in response to the evaluator's comments, and includes revisions to the paper and supplementary explanations.

[0800] "Emotion analysis engine" refers to artificial intelligence that analyzes the user's emotional state and adjusts the tone and style of each interaction.

[0801] In order to implement the present invention, it is necessary to configure the following system and execute the program.

[0802] System configuration

[0803] server:

[0804] The server contains a generative AI model, database, format correction module, translation correction module, evaluator opinion analysis module, response generation module, and sentiment analysis engine. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the user's device.

[0805] Device:

[0806] The terminal provides an interface where users can upload research files, input history information, and check suggestions and corrections from the server. The terminal also supports data communication between the user and the server. It also provides an interface with emotion recognition functionality to analyze the user's emotional state.

[0807] User:

[0808] As a researcher, users manage the process of submitting research files through their devices. Specifically, they submit research files, select potential recipients, review and resubmit revised and proofread files, respond to comments from reviewers, and communicate their emotional state to the system through emotion recognition.

[0809] Program processing explanation

[0810] server:

[0811] 1. Receiving thesis and biographical information:

[0812] The server stores the research result files and history information sent by users in a database, and then prepares them for analysis.

[0813] 2. Suggestions for potential recipients:

[0814] The server uses a generative AI model to analyze the content and history of research file files, and lists suitable submission candidates. An emotion analysis engine recognizes the user's emotional state and adjusts the suggestions accordingly.

[0815] 3. Format correction:

[0816] Once a user selects a submission destination, the server retrieves the destination's specifications and automatically formats the research file into the specified format. A sentiment analysis engine adjusts the tone and style of the format based on the user's emotional state.

[0817] 4. Translation corrections:

[0818] The server's translation correction module checks the formatted research file for appropriate grammar, style, and terminology, and makes any necessary corrections. The sentiment analysis engine adjusts the tone and style of the corrections based on the user's emotional state.

[0819] 5. Analysis of evaluator opinions:

[0820] When a user resubmits or reviews a review, the user sends the evaluator's comments to the server, which uses the opinion analysis module to suggest additional experiment plans or modifications. The sentiment analysis engine adjusts the suggestions based on the user's emotional state.

[0821] 6. Response Generation:

[0822] The server automatically generates a response based on the evaluator's opinion and sends it to the user. The sentiment analysis engine adjusts the tone and style of the response based on the user's emotional state. The user then checks and edits the response and sends it back to the evaluator.

[0823] Device:

[0824] 1. Data Entry:

[0825] Users upload research result files and enter history information through their terminals, which then send this data to the server.

[0826] 2. Confirm potential recipients:

[0827] The server sends a list of possible submission destinations to the user, which are then displayed on the device, allowing the user to select the most appropriate one. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0828] 3. Download the fix:

[0829] Users will be able to download research result files that have been formatted and translated via their terminals.

[0830] 4. Providing reviewer feedback:

[0831] After reposting, the user sends the feedback received from the reviewers from their device to the server. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0832] 5. Check the response:

[0833] The response sent from the server is displayed on the device, and the user confirms and corrects it before sending it to the evaluator. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0834] Specific operation example

[0835] When a researcher submits "sample_paper.pdf" to the server, the server begins analyzing the research results file and history information. The generative AI model analyzes the contents of the research results file and, based on past history information, suggests possible submission destinations such as "Journal A," "Journal B," and "Journal C." The sentiment analysis engine analyzes the user's emotional state and, for example, if stress is high, emphasizes the suggestion of "Journal B," which has a quick review process. The researcher confirms this on their device and selects "Journal A."

[0836] The server then edits "sample_paper.pdf" according to the formatting specifications of "Journal A," and a sentiment analysis engine adjusts the tone and style of the format based on the user's stress level. The translation correction module then examines grammar, style, and terminology, and the sentiment analysis engine adjusts the tone and style. The revised research output file is then provided to the researcher, who is then encouraged to resubmit.

[0837] After resubmitting, researchers receive comments from evaluators and send them to the server. The server then uses a comment analysis module to propose additional experimental plans and a response generation module to create a response to the evaluators. An emotion analysis engine adjusts the content of the proposal and the tone of the response based on the user's emotional state. In this way, researchers can quickly and efficiently resubmit their research results and respond to evaluator comments.

[0838] Examples of prompts:

[0839] Please explain the process of a researcher submitting a research result file to a server. Please also explain the process of the server accepting the research result file, analyzing it, suggesting suitable submission destinations, and correcting the format and translation based on emotion recognition. Also, please explain the process of generating a response to a comment.

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

[0841] Step 1:

[0842] Receiving papers and historical information

[0843] Input: The user uses the terminal to upload the research output file (e.g., "sample_paper.pdf") and history information (e.g., past submission history).

[0844] Specific operation: The terminal receives the research result file and history information provided by the user and transmits this data to the server.

[0845] Output: The server stores the received data in a database.

[0846] Step 2:

[0847] Suggestions for potential recipients

[0848] Input: Research output files and historical information stored in the server's database.

[0849] How it works: The server uses generative AI models to analyze the content and history of research files, for example, using topic modeling to identify research topics and then lists the best candidates for submission.

[0850] Output: Sends suggested submission candidates (e.g. "Journal A", "Journal B", "Journal C") to the user's device.

[0851] Step 3:

[0852] Format correction

[0853] Input: The submission destination selected by the user (e.g. "Journal A").

[0854] What it does: When a user selects a submission destination, the server retrieves the destination's formatting requirements and automatically formats the research file according to the specified format (e.g., font, paragraph style, citation format, etc.). The sentiment analysis engine adjusts the tone and style of the format based on the user's emotional state.

[0855] Output: Research results file in modified format.

[0856] Step 4:

[0857] Translation fixes

[0858] Input: Research results file in modified format.

[0859] What it does: The server uses a translation correction module to check for appropriate grammar, style, and terminology and make any necessary corrections. The sentiment analysis engine adjusts tone and style based on the user's emotional state.

[0860] Output: Research results file with translation correction completed.

[0861] Step 5:

[0862] Download the fixed version

[0863] Input: Research results file with translation corrections completed.

[0864] Specific operation: The server is configured to provide the modified research result file to the user's terminal, and the user can download the file from the terminal.

[0865] Output: The modified research file downloaded by the user.

[0866] Step 6:

[0867] Providing evaluator opinions

[0868] Input: Input received from reviewers after resubmission (e.g., comments and feedback).

[0869] Specific operation: The user sends the evaluator's opinion from the device to the server. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0870] Output: Rater opinions and user emotional state data sent to the server.

[0871] Step 7:

[0872] Analysis of evaluator opinions

[0873] Input: Rater opinions and user emotional state data sent to the server.

[0874] Specific operation: The server uses the opinion analysis module to analyze the evaluator's opinions. Based on this, it proposes additional experiment plans and modifications. The sentiment analysis engine adjusts the proposals based on the user's emotional state.

[0875] Output: Suggested additional experimental designs and modifications.

[0876] Step 8:

[0877] Response Generation

[0878] Input: Additional experimental design and modifications based on the reviewer's comments.

[0879] How it works: The server uses a response generation module to automatically generate responses for the evaluator. The sentiment analysis engine adjusts the tone and style of the responses based on the user's emotional state.

[0880] Output: The response sent to the user.

[0881] Step 9:

[0882] Check the response

[0883] Input: The response sent by the server.

[0884] Specific operation: The user checks the response on the device, corrects it if necessary, and sends it to the evaluator. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0885] Output: Modified response sentences and user emotional state data.

[0886] (Application example 2)

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

[0888] Evaluating security policies and audit reports requires specialized knowledge, time, and effort. Human error and incompleteness in the evaluation process can affect the accuracy of risk assessments. Furthermore, proposing security measures and responding to reviewer comments must be done efficiently and quickly, but these processes require advanced knowledge and experience, making them difficult for many companies. Therefore, there is a need for a system that automates security evaluations, reduces the burden on users, and performs highly accurate risk assessments.

[0889] The identification process by the identification 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 receiving a document file and inspection history from a user, means for analyzing the received document file and inspection history to propose optimal candidate evaluation sites, means for automatically correcting the format of the document file in accordance with the specifications of the proposed evaluation sites, means for grammar proofreading the document file, means for analyzing comments from reviewers to propose additional inspection plans and corrections, means for automatically generating a response to the reviewer, and means for analyzing the reviewer's emotional state to adjust the tone and style of the suggestions and the response. This automates the evaluation of security policies and audit reports, reducing the user's burden and enabling efficient and rapid, highly accurate risk assessment.

[0890] A "document file" is a text document that is the subject of evaluation, such as a security policy or an audit report.

[0891] "Inspection history" refers to records of past audits and security inspections and the resulting data.

[0892] "Evaluation candidates" are candidates for organizations or systems that are proposed as targets for which document files should be evaluated.

[0893] "Format correction" is the process of automatically formatting and adjusting a document file to conform to the specifications of the proposed evaluation site.

[0894] "Grammar proofreading" is the process of checking the grammar, style, and terminology in a document and making any necessary corrections.

[0895] "Reviewer comments" are feedback or suggestions provided by the reviewer of a document file.

[0896] "Additional Inspection Plan" is a plan for additional security inspections or evaluations proposed based on reviewer comments.

[0897] "Modifications" are proposed changes or adjustments to the document file or security policy based on reviewer comments.

[0898] A "response" is a text that contains a response or rebuttal to a reviewer's comment.

[0899] "Emotional state" refers to a psychological state that indicates a user's stress level and emotional changes.

[0900] "Tone and style" refers to the way a document or response is presented or worded, and is adjusted according to the user's emotional state.

[0901] In order to implement the present invention, it is necessary to configure a security evaluation system and execute the following programs.

[0902] System configuration

[0903] server:

[0904] The server contains a generative AI model, database, formatting correction module, grammar proofreading module, reviewer comment analysis module, response generation module, and emotion engine. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the users' devices.

[0905] Device:

[0906] The terminal provides an interface where users can upload document files, input inspection history, and check suggestions and correction results from the server. The terminal also supports data communication between the user and the server. It also provides an interface with emotion recognition functionality to analyze the user's emotional state.

[0907] User:

[0908] As a company security officer, users manage the evaluation process of security policies and audit reports through their terminals. Specifically, they submit document files, select candidates for evaluation, review and resubmit corrected and proofread documents, respond to comments from reviewers, and communicate their emotional state to the system through emotion recognition.

[0909] Program processing explanation

[0910] server:

[0911] 1. Receiving document files and inspection history:

[0912] The server stores the document files and inspection history sent by the user in a database, and then prepares them for analysis.

[0913] 2. Suggestion of candidate evaluation sites:

[0914] The server uses a generative AI model to analyze the document file and inspection history, and then lists appropriate evaluation candidates and sends them to the user's device. The emotion engine recognizes the user's emotional state and adjusts the suggestions accordingly.

[0915] 3. Formatting corrections:

[0916] When a user selects a rating destination, the server retrieves the rating destination's formatting specifications and automatically converts the document file into the specified format. The emotional engine adjusts the tone and style of the format based on the user's emotional state.

[0917] 4. Grammar proofreading:

[0918] The server-based grammar correction module checks the formatted document file for appropriate grammar, style, and terminology, and makes any necessary corrections. The emotion engine adjusts the tone and style of the correction based on the user's emotional state.

[0919] 5. Reviewer Comment Analysis:

[0920] When a user resubmits or receives reviewer comments after review, the server uses a comment analysis module to suggest additional inspection plans and corrections. The emotion engine adjusts the suggestions based on the user's emotional state.

[0921] 6. Response Generation:

[0922] The server automatically generates a response based on the reviewer's comments and sends it to the user. The emotion engine adjusts the tone and style of the response based on the user's emotional state. The user can then review and edit the response before sending it to the reviewer.

[0923] Device:

[0924] 1. Data Entry:

[0925] Users upload document files and enter inspection history through their terminals, which then send this data to the server.

[0926] 2. Confirmation of potential evaluation targets:

[0927] The server sends a list of potential rating recipients to the user's device, and the user selects the most appropriate one. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0928] 3. Download the fix:

[0929] The user can download the document that has been formatted and grammar corrected through the terminal.

[0930] 4. Provide reviewer comments:

[0931] After resubmission, the user sends the comments received from the reviewer from their device to the server, where the emotion recognition function analyzes the user's emotional state and sends the results to the server.

[0932] 5. Check the response:

[0933] The response sent from the server is displayed on the device, and the user can check and edit it before sending it to the reviewer. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[0934] Specific examples

[0935] When a company's security officer submits "Security Policy.pdf" to the server, the server receives the document and its inspection history and begins analysis. Based on the document's content and past inspection history, the generative AI model suggests "Assessment Agency A," "Assessment Agency B," and "Assessment Agency C" as potential evaluation candidates. The emotion engine analyzes the user's stress level and, if stress levels are high, emphasizes the suggestion of "Assessment Agency B," which has a faster evaluation process. The officer reviews this on their device and selects "Assessment Agency A." The server then modifies "Security Policy.pdf" according to the formatting specifications of "Assessment Agency A," and the emotion engine adjusts the tone and style of the formatting based on the user's stress level. The grammar proofreading module then scrutinizes grammar, style, and terminology, and the emotion engine adjusts the tone and style. The revised document is provided to the officer for resubmission. After resubmission, the officer receives comments from the reviewers and sends them to the server, which proposes additional inspection plans and creates a response to the reviewer using the response generation module. The emotion engine adjusts the suggestion content and tone of the response based on the user's emotional state. In this way, personnel can quickly and efficiently evaluate and revise security policies.

[0936] Example prompts for generative AI models

[0937] "Analyze the security audit report and answer the following questions:

[0938] 1. Which of the security measures you have implemented are weak? Which areas need improvement?

[0939] 2. What are the recommended measures to address the identified risks?

[0940] 3. What message should you convey to users? Tailor your suggestions to them, especially considering their stress levels.

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

[0942] Step 1:

[0943] The user uses a terminal to upload a document file (e.g., "SecurityPolicy.pdf") and inspection history. The terminal sends this data to the server. The server receives the document file and inspection history and stores them in a database. The input data is the document file and inspection history, and the output data is a notification that the data has been successfully saved to the database.

[0944] Step 2:

[0945] The server uses a generative AI model to analyze the saved document file and inspection history. The input data is the document file and inspection history, and the output data is the analysis results, which are evaluation destination candidates (e.g., "Evaluation Agency A," "Evaluation Agency B," "Evaluation Agency C"). The generative AI model analyzes the document content and performs the process of suggesting the most suitable evaluation destination.

[0946] Step 3:

[0947] The server uses an emotion engine to analyze the user's emotional state at the time of upload. The input data for emotion recognition is the user's facial expressions and voice data, and the output data is the analyzed emotional state (e.g., stress level). The suggestions are adjusted based on the analysis results.

[0948] Step 4:

[0949] The server sends the candidate evaluation destinations to the terminal. The terminal displays them to the user, who selects the most suitable evaluation destination. Information on the selected evaluation destination is sent to the server. The input data is the candidate evaluation destinations, and the output data is the selected evaluation destination.

[0950] Step 5:

[0951] The server obtains the format specification of the selected evaluation target and automatically converts the document file to the specified format. The input data is the document file and the format specification, and the output data is the document file after formatting correction. The server uses the format correction module to adjust the tone and style based on the emotion engine.

[0952] Step 6:

[0953] The server uses a grammar correction module to check the formatted document file for appropriate grammar, style, and terminology, and makes any necessary corrections. The input data is the formatted document file, and the output data is the grammar-corrected document file. The emotion engine adjusts the tone and style of the proofreading. The proofread document file is then sent to the terminal, ready for the user to download.

[0954] Step 7:

[0955] The user uses a terminal to check the document file after formatting and grammar correction has been completed and resubmit it. The server receives the resubmitted document file along with the reviewer comments. The input data is the document file and the reviewer comments, and the output data is a notification of successful upload to the server.

[0956] Step 8:

[0957] The server uses the reviewer comment analysis module to analyze the reviewer comments and propose additional inspection plans and corrections. The input data is the reviewer comments, and the output data is the proposed additional inspection plans and corrections. The analysis results are sent to the terminal and displayed to the user.

[0958] Step 9:

[0959] The server uses a response generation module to automatically generate responses based on reviewer comments. The input data is the reviewer comments, and the output data is the generated response. The emotion engine adjusts the tone and style of the response. The generated response is sent to the device, where the user can review and edit it.

[0960] Step 10:

[0961] The user uses a terminal to check the generated response, make any necessary corrections, and send it to the reviewer. The input data is the generated response and any user corrections, and the output data is the final response. This process allows the user to efficiently evaluate security policies and audit reports and respond to reviewer comments.

[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 type 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] To implement the present invention, it is necessary to configure a system and execute a program as follows.

[0979] System configuration

[0980] server:

[0981] The server contains a generative AI model, a database, a formatting correction module, an English proofreading module, a reviewer comment analysis module, and a response generation module. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the user's device.

[0982] Device:

[0983] The terminal provides an interface where users can upload their paper files, enter their submission history, and check the server's suggestions and corrections. The terminal also supports data communication between the user and the server.

[0984] User:

[0985] As a researcher, users manage the paper submission process through their devices: submitting paper files, selecting potential publication destinations, reviewing and resubmitting revised and proofread papers, and responding to comments from reviewers.

[0986] Program processing explanation

[0987] server:

[0988] 1. Receiving your manuscript and submission history:

[0989] The server stores the submitted paper files and submission history in a database, and the stored data is then analyzed.

[0990] 2. Suggestions for potential publications:

[0991] The server uses the generative AI model to analyze the content of the paper and its submission history, compiles a list of suitable submission candidates, and sends it to the user's device.

[0992] 3. Formatting corrections:

[0993] When a user selects a submission destination, the server retrieves the formatting specifications of that destination and automatically converts the paper file into the specified format.

[0994] 4. English Proofreading:

[0995] The English proofreading module on the server checks the corrected format of the paper file for appropriate grammar, style, and terminology, and makes any necessary corrections.

[0996] 5. Reviewer Comment Analysis:

[0997] When a user resubmits or reviews a review, they send the reviewer comments they received to the server, which then uses a comment analysis module to suggest additional experiment plans or corrections.

[0998] 6. Response Generation:

[0999] The server automatically generates a response based on the reviewer's comments and sends it to the user, who then checks and edits it before sending it back to the reviewer.

[1000] Device:

[1001] 1. Data Entry:

[1002] Users upload their paper files and enter their submission history through their terminals, which then send this data to the server.

[1003] 2. Check potential publications:

[1004] The candidate posting destinations sent from the server are displayed on the terminal, and the user selects the most suitable posting destination.

[1005] 3. Download the fix:

[1006] Users will be able to download papers that have been formatted and proofread through their terminals.

[1007] 4. Provide reviewer comments:

[1008] After reposting, the user sends the comments received from the reviewer from the terminal to the server.

[1009] 5. Check the response:

[1010] The response sent from the server is displayed on the terminal, and the user checks and corrects it before sending it to the reviewer.

[1011] Specific examples

[1012] When Dr. A submits "sample_paper.pdf" to the server, the server receives the paper and its submission history and begins analysis. Based on the paper's content and past submission history, the generative AI model suggests "Journal A," "Journal B," and "Journal C" as possible publication destinations. Dr. A reviews this on his device and selects "Journal A." The server then edits "sample_paper.pdf" in accordance with Journal A's formatting specifications and scrutinizes the text using the English proofreading module. The server then provides the revised paper to Dr. A for resubmission. After resubmission, Dr. A receives comments from reviewers and sends them to the server, which then proposes additional experimental plans and creates responses to the reviewers using the response generation module. In this way, Dr. A can quickly and efficiently resubmit or revise his paper.

[1013] The processing flow will be explained below.

[1014] Step 1:

[1015] Users upload their paper files and enter their submission history using their terminals. Once the data is complete, it is sent to the server.

[1016] Step 2:

[1017] The server receives the paper files and submission history sent by the user and stores this data in a database. After storing it, it prepares it for analysis.

[1018] Step 3:

[1019] The server uses the generated AI model to analyze the contents of the paper file and the submission history. Based on the analysis results, it creates a list of optimal submission candidates and sends it to the user's device.

[1020] Step 4:

[1021] The terminal displays the list of candidate posting destinations sent from the server, and provides an interface that allows the user to check this list.

[1022] Step 5:

[1023] The user checks the list of possible posting destinations on the device and selects the most suitable destination. The selected information is sent to the server.

[1024] Step 6:

[1025] The server retrieves the formatting requirements of the submission destination selected by the user from the database, automatically corrects the format of the paper file to conform to those requirements, generates the corrected file, and sends it to the user's device.

[1026] Step 7:

[1027] The terminal displays the formatted paper file sent from the server and provides the user with a downloadable link.

[1028] Step 8:

[1029] The user downloads the corrected formatted paper and checks its contents.

[1030] Step 9:

[1031] The server then runs the revised paper file through the English proofreading module, checking for appropriate grammar, style, and terminology, making any necessary corrections, and generates a proofread file that is sent to the user's device.

[1032] Step 10:

[1033] The terminal displays the proofread paper for the user to review and download.

[1034] Step 11:

[1035] The user checks the edited paper and resubmits it.

[1036] Step 12:

[1037] The user inputs the comments received from the reviewer after reposting into the terminal and transmits them to the server.

[1038] Step 13:

[1039] The server receives the reviewer comments, analyzes them using the generation AI, proposes necessary additional experiment plans and corrections, and sends the results to the user's device.

[1040] Step 14:

[1041] The terminal displays the additional experiment plan and modifications sent from the server, and provides an interface for the user to check them.

[1042] Step 15:

[1043] The user checks the proposal and makes any necessary corrections or additional experiments.

[1044] Step 16:

[1045] The server automatically generates a response based on the reviewer's comments and sends it to the user's device, allowing the user to check, modify, and submit the response.

[1046] Step 17:

[1047] The user checks and edits the response and sends it to the reviewer.

[1048] In this way, the system supports users in efficiently resubmitting papers and responding to reviewers.

[1049] Example 1

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

[1051] Traditionally, the paper submission process required researchers to manually perform a wide range of tasks, including selecting a journal to submit to, formatting, proofreading, and responding to reviewer comments, which required a great deal of time and effort. The process of selecting a journal and formatting was particularly complex and prone to errors. It was also difficult to find an appropriate response to reviewer comments. To solve these issues, an automated system is needed.

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

[1053] In this invention, the server includes means for receiving a paper file and submission history from a user, means for analyzing the received paper file and submission history and using a generative AI model to suggest optimal submission destination candidates, means for automatically correcting the format of the paper file to conform to the specifications of the suggested submission destinations, means for proofreading the corrected paper file, means for analyzing reviewer comments received by the user after resubmission and suggesting additional experimental plans and corrections, and means for automatically generating replies to reviewers. This streamlines the paper submission process, reduces the workload on researchers, and improves the success rate of submissions.

[1054] A "paper file" refers to a document that summarizes research results and considerations submitted by a user, and is saved in a format such as a PDF or text file.

[1055] "Submission history" refers to information that records the journals to which a user has submitted papers, the results, and the feedback they received.

[1056] A "generative AI model" refers to an algorithm that uses artificial intelligence to analyze user input data and suggest potential posting destinations.

[1057] "Formatting" refers to the process of automatically adjusting page layout, fonts, citation style, etc. of a paper file in accordance with the specified submission guidelines.

[1058] "Proofreading" refers to the process of checking and correcting English grammar, style, and vocabulary for accuracy.

[1059] "Reviewer comments" refers to the feedback and evaluation provided by a journal's reviewers on a paper.

[1060] "Additional experimental plan" refers to a plan for experiments or research activities that should be added to the paper, suggested based on reviewer comments.

[1061] "Revisions" refer to the parts or content in the paper that need to be revised based on reviewer comments.

[1062] A "response" refers to a text that summarizes a user's response or rebuttal to a comment received from a reviewer.

[1063] To implement the present invention, it is necessary to configure a system and execute a program as follows.

[1064] System configuration

[1065] server:

[1066] The server contains a generative AI model, a database, a formatting correction module, an English proofreading module, a reviewer comment analysis module, and a response generation module. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the users' devices.

[1067] Device:

[1068] The terminal provides an interface for users to upload paper files, enter their submission history, and check the server's suggestions and corrections. The terminal also supports data communication between the user and the server.

[1069] User:

[1070] As a researcher, users manage the paper submission process through their devices: submitting paper files, selecting potential publication destinations, reviewing and resubmitting revised and proofread papers, and responding to comments from reviewers.

[1071] Program processing explanation

[1072] server:

[1073] The server stores the submitted paper files and submission history in a database, which is then analyzed by a generative AI model.

[1074] The server uses a generative AI model to analyze the content of the paper and its submission history, compiles a list of suitable submission candidates, and sends it to the user's device.

[1075] When a user selects a submission destination, the server retrieves the formatting specifications of that destination and automatically converts the paper file into the corresponding format.

[1076] The English proofreading module on the server checks the corrected paper file for appropriate grammar, style, and terminology, and makes any necessary corrections.

[1077] When a user resubmits or reviews a review, the reviewer comments received are sent to the server, where they are analyzed using a comment analysis module, which then proposes additional experimental plans and corrections.

[1078] The server automatically generates a response based on the reviewer's comments and sends it to the user, who then checks and corrects it and sends it back to the reviewer.

[1079] Device:

[1080] Users upload their paper files and enter their submission history via their terminals, and this data is sent to the server.

[1081] The candidate posting destinations sent from the server are displayed on the terminal, and the user selects the most suitable posting destination.

[1082] The terminal provides the paper with formatting correction and English proofreading completed so that the user can download the corrected paper.

[1083] After reposting, the user sends the comments received from the reviewer from the terminal to the server.

[1084] The response sent from the server is displayed on the terminal, and the user checks and corrects it before sending it to the reviewer.

[1085] Specific examples

[1086] When Dr. A submits "sample_paper.pdf" to the server via his / her device, the server receives the paper file and submission history and stores them in a database. Next, it uses a generative AI model to analyze the paper content and submission history, suggesting potential publication destinations such as "Journal A," "Journal B," and "Journal C." This information is then sent to the user's device. When Dr. A selects "Journal A" on his / her device, the server modifies "sample_paper.pdf" based on the formatting specifications of that publication. The English proofreading module then checks grammar and style and makes any necessary corrections. The revised paper is then provided to the user's device, where Dr. A can review and resubmit it. After resubmission, Dr. A receives comments from the reviewers and sends them from his / her device to the server. The server analyzes the comments and suggests additional experimental plans and revisions. The response generation module then generates a response to the reviewer and sends it to Dr. A. Dr. A reviews and edits the response and finally sends it to the reviewer.

[1087] Prompt Sentence Examples

[1088] "Please explain how the server formats the paper."

[1089] "Please explain specifically how to use a generative AI model to suggest potential posting destinations."

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

[1091] Step 1:

[1092] The user uses the terminal to upload the paper file (e.g., "sample_paper.pdf") and submission history. This becomes the input data. The terminal then sends this data to the server. Specifically, the system transfers the file specified by the user to the server using the system's upload function.

[1093] Step 2:

[1094] The server receives the paper file and submission history data sent from the terminal and stores them in a database. This data becomes input data. The specific operations performed by the server include storing the received file in the appropriate table in the database and, if necessary, verifying the integrity of the data.

[1095] Step 3:

[1096] The server uses a generative AI model to analyze the saved paper files and submission history. The input data are the saved paper files and submission history. As a result of the analysis, the server generates a list of suitable submission candidates (e.g., "Journal A," "Journal B," "Journal C"), which becomes the output. Specifically, the generative AI model analyzes the content of the uploaded paper based on the content and past submission history, and then recommends appropriate journals.

[1097] Step 4:

[1098] The server sends the generated list of candidate destinations to the user's terminal. The input data is the generated list of candidate destinations, and the output is the data sent to the user's terminal. Specifically, the server performs a data transfer process to notify the user's terminal of an appropriate list of candidate destinations.

[1099] Step 5:

[1100] The user checks the list of suggested posting destinations on the device and selects the most suitable posting destination from among them (e.g., "Journal A"). The input data is the list of candidate posting destinations, and the output is the selected posting destination. Specifically, the user operates the device interface to perform operations such as clicking a selection button.

[1101] Step 6:

[1102] The server obtains the journal specifications selected by the user and automatically formats the paper file accordingly. The input data is the selected journal and the original paper file, and the output is the formatted paper file. Specifically, the server obtains the format specifications of the journal and automatically adjusts the uploaded paper to comply with those specifications.

[1103] Step 7:

[1104] The server applies the English proofreading module to the paper file after formatting correction is complete. The input data is the paper file after formatting correction, and the output is the proofread paper file. Specifically, the English proofreading module checks the appropriateness of grammar and vocabulary and makes any necessary corrections.

[1105] Step 8:

[1106] The server sends the proofread paper file to the user's terminal. The input data is the proofread paper file, and the output is the revised paper file sent to the terminal. Specifically, the server performs data communication processing to transfer the proofread paper file to the user's terminal.

[1107] Step 9:

[1108] The user checks the revised paper file on their device and resubmits it. The input data is the proofread paper file, and the output is the resubmitted paper file. Specifically, the user checks the revised text on their device and then goes through the process of resubmitting it to the journal's submission site.

[1109] Step 10:

[1110] The user sends the reviewer comments received after reposting from the terminal to the server. The input data is the reviewer comments, and the output is the reviewer comments sent to the server. Specifically, the user uploads a file of review comments and sends it to the server.

[1111] Step 11:

[1112] The server uses a reviewer comment analysis module to analyze the received comments and propose additional experiment plans and modifications. The input data are reviewer comments, and the output is proposals as the analysis results. Specifically, the comment analysis module analyzes the comment content and lists recommended experiment plans and modifications.

[1113] Step 12:

[1114] The server automatically generates a response based on the reviewer's comments and sends it to the user. The input data is the analyzed reviewer's comments, and the output is the generated response. Specifically, the response generation module automatically creates an appropriate response based on the analysis results and sends it to the terminal.

[1115] Step 13:

[1116] The user checks and corrects the response on the device and sends it to the reviewer. The input data is the generated response, and the output is the corrected response. Specifically, the user checks the response on the device, makes any necessary corrections, and then sends it to the reviewer.

[1117] (Application example 1)

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

[1119] Currently, quality control processes in factories require a lot of manual work and time, resulting in problems such as reduced efficiency and the risk of human error. Furthermore, analyzing feedback and proposing improvement measures relies on experience and expertise, which can lead to a lack of consistency. Therefore, there is a need to automate and streamline these processes.

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

[1121] In this invention, the server includes means for receiving a paper file and submission history from a user, means for analyzing the received paper file and submission history to suggest optimal submission destination candidates, means for automatically correcting the format of the paper file to conform to the specifications of the suggested submission destination, means for proofreading the paper file, means for analyzing comments from reviewers to suggest additional experiment plans and corrections, means for automatically generating a quality control report, means for automatically correcting the generated report to a specified format, means for analyzing feedback and identifying areas for improvement, means for proposing improvement measures based on the areas for improvement, and means for automatically generating a response to the reviewer. This automates the quality control process within the factory, enabling efficient and consistent analysis of feedback and proposal of improvement measures.

[1122] "User" means a person or organization that uses the system to manage the manuscript submission process and quality control process.

[1123] A "paper file" is a digital document of an academic paper written by a researcher.

[1124] A "submission history" is a record of which journals and academic publications a researcher has submitted papers to in the past.

[1125] "Analysis" is the process of converting input data into meaningful information.

[1126] The "best publication candidates" are a list of academic journals and journals suitable for submitting a paper, suggested based on the analysis results.

[1127] "Formatting" is the process of automatically changing the format of a paper file according to certain rules.

[1128] "English proofreading" is the process of checking English texts for appropriate grammar, style, and terminology, and making any necessary corrections.

[1129] "Reviewer comments" are evaluations and feedback given by reviewers of a paper on its content.

[1130] "Additional Experiment Plan" is a plan for additional experiments that are proposed based on reviewer comments.

[1131] "Revisions" are the specific changes needed to improve the paper based on reviewer comments.

[1132] A "response" is a written response or reply made by a researcher to a reviewer's comment.

[1133] A "quality control report" is a document that organizes data on product quality within a factory and reports on the quality status.

[1134] "Feedback" refers to evaluations and comments received from superiors, quality control departments, etc.

[1135] "Improvements" are specific areas for improving a product or process that are identified based on feedback.

[1136] "Improvements" are proposed ways to improve a product or process based on improvements.

[1137] To implement this invention, it is necessary to configure the following system and run the program. The main components of the system are a server, a terminal, and a user. This invention is designed specifically to streamline the quality control process in factories.

[1138] System configuration

[1139] server

[1140] The server contains a generative AI model, a database, a formatting correction module, an English proofreading module, a feedback analysis module, and a module for suggesting improvements. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the terminal.

[1141] Terminal

[1142] The terminal provides an interface for users to upload quality control reports, input feedback, and view suggestions and corrections from the server. The terminal supports data communication between the user and the server.

[1143] User

[1144] As a quality control officer at a factory, the user manages the quality control process through the terminal, submitting quality control reports, inputting feedback, and confirming and implementing corrections and improvements.

[1145] Program processing explanation

[1146] server

[1147] The server stores the quality control reports and feedback received from the devices in a database. A generative AI model automatically generates quality control reports based on data collected from sensors and inspection equipment. During this process, the stored data is analyzed. AI models used include GPT-3 and SpellChecker.

[1148] The server has a format correction module that automatically corrects the generated report into a specified format. If the corrected report is in English, the English proofreading module checks the appropriateness of grammar, style, and terminology and makes any necessary corrections.

[1149] The feedback analysis module analyzes the feedback provided by users and identifies specific areas for improvement. Based on these results, the improvement proposal module generates specific improvement measures and provides them to users. This allows users to efficiently identify and implement improvements to their quality control.

[1150] Terminal

[1151] The terminal provides an interface for users to upload quality control reports and enter feedback. The terminal transmits this data to the server, where the user can check the correction results and improvement suggestions sent by the server. The terminal also makes the generated quality control reports and suggested improvements available for download.

[1152] Specific examples

[1153] For example, suppose a quality control officer at a factory submits a file called "sensor_data.csv" to the server. The server receives the data and uses a generative AI model to automatically generate a quality control report. At that time, the server specifies the format "quality control report" and automatically corrects the format.

[1154] When a user sends feedback received from their superior to the server from their device, the feedback analysis module begins analysis to identify specific areas for improvement. Then, using a generative AI model, it proposes appropriate improvement measures, enabling the person in charge to quickly and efficiently improve their quality control process.

[1155] Prompt Sentence Examples

[1156] "Generate a quality control report based on the data from the sensors in the following format:

[1157] Data Overview

[1158] Problem

[1159] Current measures

[1160] Recommended Improvements

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

[1162] Step 1:

[1163] The user uploads quality control reports and feedback via the terminal and sends them to the server. The input data is the quality control report (e.g., "sensor_data.csv") and feedback, and data is transmitted from the terminal to the server. The output is the uploaded data stored in the server's database.

[1164] Step 2:

[1165] The server stores the received quality control reports in a database. This stored data is then used for analysis. Specifically, the server inserts the data into the database in the appropriate format. The input is the uploaded quality control report data, and the output is the data already stored in the database.

[1166] Step 3:

[1167] The server uses a generative AI model (e.g., GPT-3) to automatically generate a report based on the stored quality control report data. During this process, a prompt is input into the generative AI model, which generates text based on the required data. The input is the quality control report data and the prompt, and the output is the generated quality control report text. An example of a specific prompt is, "Based on data from the sensors, please generate a quality control report in the following format: - Data summary - Problem - Current measures - Recommended improvement measures."

[1168] Step 4:

[1169] The server automatically modifies the generated quality control report to the specified format. It uses a format modification module to convert the data to fit the required layout and format. The input is the generated quality control report text and formatting specifications, and the output is the modified report. Specifically, it adjusts the layout and adds the necessary headers and footers.

[1170] Step 5:

[1171] If the corrected report is in English, the server's English proofreading module checks the grammar, style, and terminology for appropriateness and makes any necessary corrections. The input is the corrected English report, and the output is the proofread report. Specifically, grammar checks and style guide-based corrections are made.

[1172] Step 6:

[1173] The user sends the feedback received from the superior or quality control department from the terminal to the server. The feedback data is used as input, and the server takes the feedback stored in the database. The output is the saved feedback data.

[1174] Step 7:

[1175] The server's feedback analysis module analyzes the feedback provided by users and identifies areas for improvement. The input is the feedback data, and the output is the identified areas for improvement. Specific operations include analyzing the feedback text and performing automatic scoring and keyword extraction.

[1176] Step 8:

[1177] Based on the analysis results, the server's improvement suggestion module generates specific improvement suggestions and provides them to the user. The suggestion text is automatically generated using a generative AI model (e.g., GPT-3). The input is the analysis results and a prompt text, and the output is a suggested improvement text. An example of a specific prompt text is, "Please suggest specific improvement measures based on the feedback below."

[1178] Step 9:

[1179] The user checks the improvement proposals sent from the server on their terminal and implements them as necessary. The input is the improvement proposal, and the output is an executable action plan. Specifically, the process includes the actions of checking the proposals and formulating an implementation plan.

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

[1181] To implement the present invention, it is necessary to configure a system and execute a program as follows.

[1182] System configuration

[1183] server:

[1184] The server contains a generative AI model, database, formatting correction module, English proofreading module, reviewer comment analysis module, response generation module, and emotion engine. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the user's device.

[1185] Device:

[1186] The terminal provides an interface where users can upload their paper files, enter their submission history, and check the server's suggestions and corrections. The terminal also supports data communication between the user and the server. Furthermore, the terminal also provides an interface with emotion recognition functionality for analyzing the user's emotional state.

[1187] User:

[1188] As a researcher, users manage the paper submission process through their devices: they submit paper files, select potential publication destinations, review and resubmit revised and proofread papers, respond to reviewers' comments, and communicate their emotional state to the system through emotion recognition.

[1189] Program processing explanation

[1190] server:

[1191] 1. Receiving your manuscript and submission history:

[1192] The server stores the submitted paper files and submission history in a database, and then prepares them for analysis.

[1193] 2. Suggestions for potential publications:

[1194] The server uses a generative AI model to analyze the content of the paper and the submission history, and then creates a list of suitable submission candidates and sends it to the user's device. The emotion engine recognizes the user's emotional state and adjusts the suggestions accordingly.

[1195] 3. Formatting corrections:

[1196] Once a user selects a submission destination, the server retrieves the destination's formatting requirements and automatically converts the manuscript file into the specified format. An emotional engine adjusts the tone and style of the formatting based on the user's emotional state.

[1197] 4. English Proofreading:

[1198] The server-based English proofreading module checks the formatted manuscript file for appropriate grammar, style, and terminology, and makes any necessary corrections. The emotional engine adjusts the tone and style of the proofreading based on the user's emotional state.

[1199] 5. Reviewer Comment Analysis:

[1200] When a user resubmits or reviews a piece of content, they send the reviewer comments they received to the server, which then uses a comment analysis module to suggest additional experiment plans or corrections. The emotion engine adjusts the suggestions based on the user's emotional state.

[1201] 6. Response Generation:

[1202] The server automatically generates a response based on the reviewer's comments and sends it to the user. The emotion engine adjusts the tone and style of the response based on the user's emotional state. The user can then review and edit the response before sending it to the reviewer.

[1203] Device:

[1204] 1. Data Entry:

[1205] Users upload their paper files and enter their submission history through their terminals, which then send this data to the server.

[1206] 2. Check potential publications:

[1207] The server sends a list of potential posting destinations to the device, and the user selects the most appropriate one. The emotion recognition function analyzes the user's emotional state and sends the results to the server.

[1208] 3. Download the fix:

[1209] Users will be able to download papers that have been formatted and proofread through their terminals.

[1210] 4. Provide reviewer comments:

[1211] After reposting, the user sends the comments received from the reviewer from their device to the server, where the emotion recognition function analyzes the user's emotional state and sends it to the server.

[1212] 5. Check the response:

[1213] The response sent from the server is displayed on the device, and the user can check and edit it before sending it to the reviewer. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1214] Specific examples

[1215] When Dr. A submits "sample_paper.pdf" to the server, the server receives the paper and its submission history and begins analysis. Based on the paper's content and past submission history, the generative AI model suggests "Journal A," "Journal B," and "Journal C" as possible submission destinations. The emotion engine analyzes the user's stress level and, if stress levels are high, emphasizes the suggestion of "Journal B," which has a faster review process. Dr. A confirms this on his device and selects "Journal A." The server then edits "sample_paper.pdf" according to "Journal A's" formatting specifications, and the emotion engine adjusts the tone and style of the formatting based on the user's stress level. The English proofreading module then examines grammar, style, and terminology, and the emotion engine adjusts the tone and style accordingly. The revised paper is then provided to Dr. A for resubmission. After resubmission, Dr. A receives comments from reviewers and sends them to the server, which then proposes additional experimental plans and creates a response to the reviewers using the response generation module. The emotion engine adjusts the tone of suggestions and responses based on the user's emotional state, allowing Dr. A to quickly and efficiently resubmit or revise his paper.

[1216] The processing flow will be explained below.

[1217] Step 1:

[1218] The user uploads the paper file using a terminal and enters the submission history. Once the input is complete, the data is sent to the server by pressing the send button.

[1219] Step 2:

[1220] The server receives the submitted paper files and submission history from users and stores this data in a database. After storing the data, it begins preparation for analysis.

[1221] Step 3:

[1222] The server uses the generated AI model to analyze the content of the paper file and the submission history. At the same time, the emotion engine analyzes the user's emotional state data obtained from the device. This allows it to create a list of optimal submission candidates and adjust the suggestions according to the user's emotional state.

[1223] Step 4:

[1224] The server sends a list of suggested posting destinations to the user's device, with the list containing candidates prioritized based on the user's emotional state.

[1225] Step 5:

[1226] The terminal displays a list of candidate posting destinations sent from the server, and provides an interface that allows the user to review the list and select the most suitable posting destination.

[1227] Step 6:

[1228] The user checks the list of potential posting destinations on the device and selects the most suitable one. After selection, the selection information is sent to the server.

[1229] Step 7:

[1230] The server retrieves the formatting requirements of the user's chosen submission destination from a database and automatically formats the manuscript file to conform to those requirements. An emotional engine adjusts the tone and style of the formatting based on the user's emotional state.

[1231] Step 8:

[1232] The server generates a formatted paper file and sends it to the user's terminal.

[1233] Step 9:

[1234] The terminal displays the formatted paper file sent from the server and provides the user with a downloadable link.

[1235] Step 10:

[1236] The user downloads the corrected formatted paper and checks its contents.

[1237] Step 11:

[1238] The server runs the revised paper file through an English proofreading module, checking for appropriate grammar, style, and terminology and making any necessary corrections. An emotional engine adjusts the tone and style of the proofreading based on the user's emotional state.

[1239] Step 12:

[1240] The server generates a proofread paper file and sends it to the user's device.

[1241] Step 13:

[1242] The device will display the proofread paper and provide a link for the user to view and download.

[1243] Step 14:

[1244] The user reviews the proofread paper and, if they determine that no revisions are necessary, resubmits the paper. After resubmission, they receive comments from reviewers.

[1245] Step 15:

[1246] The user inputs the comments received from the reviewer into the device and sends them to the server. The emotion recognition function analyzes the user's emotional state and sends that data to the server.

[1247] Step 16:

[1248] The server receives reviewer comments, analyzes them using generative AI and an emotion engine, and sends them to the user, proposing additional experiment plans and modifications based on the user's emotional state.

[1249] Step 17:

[1250] The terminal displays the additional experiment plan and corrections sent from the server. The user checks this and performs any necessary corrections or additional experiments.

[1251] Step 18:

[1252] The server automatically generates a response based on the reviewer's comments and sends it to the user's device, adjusting the tone and style of the response based on the user's emotional state.

[1253] Step 19:

[1254] The device displays the response sent from the server, and the user can check and correct it before sending it to the reviewer.

[1255] In this way, the system helps users efficiently resubmit their manuscripts and respond to reviewers, and it also adjusts suggestions, formatting, proofreading, and responses taking into account the user's emotional state.

[1256] Example 2

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

[1258] Researchers face a wide range of challenges in the process of submitting academic papers. These include gathering information to select the appropriate publication, the complexity of submission formats, the burden of proofreading, and writing appropriate responses to reviewer comments. These tasks require time and effort, which increases researchers' stress. Furthermore, the impact of researchers' emotional state on these processes cannot be ignored. Conventional systems do not provide comprehensive solutions to these challenges.

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

[1260] In this invention, the server includes means for receiving a research result file and history information from a user, means for analyzing the received research result file and history information to suggest optimal candidate submission destinations, means for automatically correcting the format of the research result file to conform to the specifications of the suggested submission destinations, means for translating and correcting the research result file, means for analyzing comments from evaluators to suggest additional experimental plans and corrections, means for automatically generating responses to the evaluators, and means for analyzing the user's emotional state using an emotion analysis engine and adjusting the tone and style of each process, thereby enabling users to complete the paper submission process quickly and efficiently and reducing their mental burden.

[1261] "User" refers to the researcher or contributor who uses this system and is responsible for uploading research result files, selecting the submission destination, and responding to reviewer comments.

[1262] "Research result files" refer to academic papers and research reports uploaded to this system, and are documents that are subject to formatting correction and translation proofreading.

[1263] "History information" refers to information on past submission history and accepted papers, and is information that serves as reference data when proposing potential next submission destinations.

[1264] "Server" refers to a computer system that analyzes data received from users, suggests suitable submission candidates, and automatically performs formatting corrections and translation proofreading.

[1265] "Candidate submission destinations" refers to the most suitable academic journals or academic societies to which the paper should be submitted, as suggested by the server after analyzing the research results file and historical information.

[1266] "Format correction" refers to the act of automatically changing the format of a research results file in accordance with the regulations of the potential recipient.

[1267] "Translation correction" refers to the process of checking research files for appropriate grammar, style, and terminology and making any necessary corrections.

[1268] "Evaluator opinions" refer to comments and feedback provided by reviewers during the paper review process that may require additional experimental design or suggested revisions.

[1269] "Additional experimental plans" refer to plans for new experiments or surveys proposed based on the evaluator's opinions.

[1270] A "response" refers to a piece of writing written in response to the evaluator's comments, and includes revisions to the paper and supplementary explanations.

[1271] "Emotion analysis engine" refers to artificial intelligence that analyzes the user's emotional state and adjusts the tone and style of each interaction.

[1272] In order to implement the present invention, it is necessary to configure the following system and execute the program.

[1273] System configuration

[1274] server:

[1275] The server contains a generative AI model, database, format correction module, translation correction module, evaluator opinion analysis module, response generation module, and sentiment analysis engine. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the user's device.

[1276] Device:

[1277] The terminal provides an interface where users can upload research files, input history information, and check suggestions and corrections from the server. The terminal also supports data communication between the user and the server. It also provides an interface with emotion recognition functionality to analyze the user's emotional state.

[1278] User:

[1279] As a researcher, users manage the process of submitting research files through their devices. Specifically, they submit research files, select potential recipients, review and resubmit revised and proofread files, respond to comments from reviewers, and communicate their emotional state to the system through emotion recognition.

[1280] Program processing explanation

[1281] server:

[1282] 1. Receiving thesis and historical information:

[1283] The server stores the research result files and history information sent by users in a database, and then prepares them for analysis.

[1284] 2. Suggestions for potential recipients:

[1285] The server uses a generative AI model to analyze the content and history of research file files, and lists suitable submission candidates. An emotion analysis engine recognizes the user's emotional state and adjusts the suggestions accordingly.

[1286] 3. Format correction:

[1287] Once a user selects a submission destination, the server retrieves the destination's specifications and automatically formats the research file into the specified format. A sentiment analysis engine adjusts the tone and style of the format based on the user's emotional state.

[1288] 4. Translation corrections:

[1289] The server's translation correction module checks the formatted research file for appropriate grammar, style, and terminology, and makes any necessary corrections. The sentiment analysis engine adjusts the tone and style of the corrections based on the user's emotional state.

[1290] 5. Analysis of evaluator opinions:

[1291] When a user resubmits or reviews a review, the user sends the evaluator's comments to the server, which uses the opinion analysis module to suggest additional experiment plans or modifications. The sentiment analysis engine adjusts the suggestions based on the user's emotional state.

[1292] 6. Response Generation:

[1293] The server automatically generates a response based on the evaluator's opinion and sends it to the user. The sentiment analysis engine adjusts the tone and style of the response based on the user's emotional state. The user then checks and edits the response and sends it back to the evaluator.

[1294] Device:

[1295] 1. Data Entry:

[1296] Users upload research result files and enter history information through their terminals, which then send this data to the server.

[1297] 2. Confirm potential recipients:

[1298] The server sends a list of possible submission destinations to the user, which are then displayed on the device, allowing the user to select the most appropriate one. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1299] 3. Download the fix:

[1300] Users will be able to download research result files that have been formatted and translated via their terminals.

[1301] 4. Providing reviewer feedback:

[1302] After reposting, the user sends the feedback received from the reviewers from their device to the server. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1303] 5. Check the response:

[1304] The response sent from the server is displayed on the device, and the user confirms and corrects it before sending it to the evaluator. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1305] Specific operation example

[1306] When a researcher submits "sample_paper.pdf" to the server, the server begins analyzing the research results file and history information. The generative AI model analyzes the contents of the research results file and, based on past history information, suggests possible submission destinations such as "Journal A," "Journal B," and "Journal C." The sentiment analysis engine analyzes the user's emotional state and, for example, if stress is high, emphasizes the suggestion of "Journal B," which has a quick review process. The researcher confirms this on their device and selects "Journal A."

[1307] The server then edits "sample_paper.pdf" according to the formatting specifications of "Journal A," and a sentiment analysis engine adjusts the tone and style of the format based on the user's stress level. The translation correction module then examines grammar, style, and terminology, and the sentiment analysis engine adjusts the tone and style. The revised research output file is then provided to the researcher, who is then encouraged to resubmit.

[1308] After resubmitting, researchers receive comments from evaluators and send them to the server. The server then uses a comment analysis module to propose additional experimental plans and a response generation module to create a response to the evaluators. An emotion analysis engine adjusts the content of the proposal and the tone of the response based on the user's emotional state. In this way, researchers can quickly and efficiently resubmit their research results and respond to evaluator comments.

[1309] Examples of prompts:

[1310] Please explain the process of a researcher submitting a research result file to a server. Please also explain the process of the server accepting the research result file, analyzing it, suggesting suitable submission destinations, and correcting the format and translation based on emotion recognition. Also, please explain the process of generating a response to a comment.

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

[1312] Step 1:

[1313] Receiving papers and historical information

[1314] Input: The user uses the terminal to upload the research output file (e.g., "sample_paper.pdf") and history information (e.g., past submission history).

[1315] Specific operation: The terminal receives the research result file and history information provided by the user and transmits this data to the server.

[1316] Output: The server stores the received data in a database.

[1317] Step 2:

[1318] Suggestions for potential recipients

[1319] Input: Research output files and historical information stored in the server's database.

[1320] How it works: The server uses generative AI models to analyze the content and history of research files, for example, using topic modeling to identify research topics and then lists the best candidates for submission.

[1321] Output: Sends suggested submission candidates (e.g. "Journal A", "Journal B", "Journal C") to the user's device.

[1322] Step 3:

[1323] Format correction

[1324] Input: The submission destination selected by the user (e.g. "Journal A").

[1325] What it does: When a user selects a submission destination, the server retrieves the destination's formatting requirements and automatically formats the research file according to the specified format (e.g., font, paragraph style, citation format, etc.). The sentiment analysis engine adjusts the tone and style of the format based on the user's emotional state.

[1326] Output: Research results file in modified format.

[1327] Step 4:

[1328] Translation fixes

[1329] Input: Research results file in modified format.

[1330] What it does: The server uses a translation correction module to check for appropriate grammar, style, and terminology and make any necessary corrections. The sentiment analysis engine adjusts tone and style based on the user's emotional state.

[1331] Output: Research results file with translation correction completed.

[1332] Step 5:

[1333] Download the fixed version

[1334] Input: Research results file with translation corrections completed.

[1335] Specific operation: The server is configured to provide the modified research result file to the user's terminal, and the user can download the file from the terminal.

[1336] Output: The modified research file downloaded by the user.

[1337] Step 6:

[1338] Providing evaluator opinions

[1339] Input: Input received from reviewers after resubmission (e.g., comments and feedback).

[1340] Specific operation: The user sends the evaluator's opinion from the device to the server. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1341] Output: Rater opinions and user emotional state data sent to the server.

[1342] Step 7:

[1343] Analysis of evaluator opinions

[1344] Input: Rater opinions and user emotional state data sent to the server.

[1345] Specific operation: The server uses the opinion analysis module to analyze the evaluator's opinions. Based on this, it proposes additional experiment plans and modifications. The sentiment analysis engine adjusts the proposals based on the user's emotional state.

[1346] Output: Suggested additional experimental designs and modifications.

[1347] Step 8:

[1348] Response Generation

[1349] Input: Additional experimental design and modifications based on the reviewer's comments.

[1350] How it works: The server uses a response generation module to automatically generate responses for the evaluator. The sentiment analysis engine adjusts the tone and style of the responses based on the user's emotional state.

[1351] Output: The response sent to the user.

[1352] Step 9:

[1353] Check the response

[1354] Input: The response sent by the server.

[1355] Specific operation: The user checks the response on the device, corrects it if necessary, and sends it to the evaluator. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1356] Output: Modified response sentences and user emotional state data.

[1357] (Application example 2)

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

[1359] Evaluating security policies and audit reports requires specialized knowledge, time, and effort. Human error and incompleteness in the evaluation process can affect the accuracy of risk assessments. Furthermore, proposing security measures and responding to reviewer comments must be done efficiently and quickly, but these processes require advanced knowledge and experience, making them difficult for many companies. Therefore, there is a need for a system that automates security evaluations, reduces the burden on users, and performs highly accurate risk assessments.

[1360] The identification process by the identification 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 receiving a document file and inspection history from a user, means for analyzing the received document file and inspection history to propose optimal candidate evaluation sites, means for automatically correcting the format of the document file in accordance with the specifications of the proposed evaluation sites, means for grammar proofreading the document file, means for analyzing comments from reviewers to propose additional inspection plans and corrections, means for automatically generating a response to the reviewer, and means for analyzing the reviewer's emotional state to adjust the tone and style of the suggestions and the response. This automates the evaluation of security policies and audit reports, reducing the user's burden and enabling efficient and rapid, highly accurate risk assessment.

[1361] A "document file" is a text document that is the subject of evaluation, such as a security policy or an audit report.

[1362] "Inspection history" refers to records of past audits and security inspections and the resulting data.

[1363] "Evaluation candidates" are candidates for organizations or systems that are proposed as targets for which document files should be evaluated.

[1364] "Format correction" is the process of automatically formatting and adjusting a document file to conform to the specifications of the proposed evaluation site.

[1365] "Grammar proofreading" is the process of checking the grammar, style, and terminology in a document and making any necessary corrections.

[1366] "Reviewer comments" are feedback or suggestions provided by the reviewer of a document file.

[1367] "Additional Inspection Plan" is a plan for additional security inspections or evaluations proposed based on reviewer comments.

[1368] "Modifications" are proposed changes or adjustments to the document file or security policy based on reviewer comments.

[1369] A "response" is a text that contains a response or rebuttal to a reviewer's comment.

[1370] "Emotional state" refers to a psychological state that indicates a user's stress level and emotional changes.

[1371] "Tone and style" refers to the way a document or response is presented or worded, and is adjusted according to the user's emotional state.

[1372] In order to implement the present invention, it is necessary to configure a security evaluation system and execute the following programs.

[1373] System configuration

[1374] server:

[1375] The server contains a generative AI model, database, formatting correction module, grammar proofreading module, reviewer comment analysis module, response generation module, and emotion engine. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the users' devices.

[1376] Device:

[1377] The terminal provides an interface where users can upload document files, input inspection history, and check suggestions and correction results from the server. The terminal also supports data communication between the user and the server. It also provides an interface with emotion recognition functionality to analyze the user's emotional state.

[1378] User:

[1379] As a company security officer, users manage the evaluation process of security policies and audit reports through their terminals. Specifically, they submit document files, select candidates for evaluation, review and resubmit corrected and proofread documents, respond to comments from reviewers, and communicate their emotional state to the system through emotion recognition.

[1380] Program processing explanation

[1381] server:

[1382] 1. Receiving document files and inspection history:

[1383] The server stores the document files and inspection history sent by the user in a database, and then prepares them for analysis.

[1384] 2. Suggestion of candidate evaluation sites:

[1385] The server uses a generative AI model to analyze the document file and inspection history, and then lists appropriate evaluation candidates and sends them to the user's device. The emotion engine recognizes the user's emotional state and adjusts the suggestions accordingly.

[1386] 3. Formatting corrections:

[1387] When a user selects a rating destination, the server retrieves the rating destination's formatting specifications and automatically converts the document file into the specified format. The emotional engine adjusts the tone and style of the format based on the user's emotional state.

[1388] 4. Grammar proofreading:

[1389] The server-based grammar correction module checks the formatted document file for appropriate grammar, style, and terminology, and makes any necessary corrections. The emotion engine adjusts the tone and style of the correction based on the user's emotional state.

[1390] 5. Reviewer Comment Analysis:

[1391] When a user resubmits or receives reviewer comments after review, the server uses a comment analysis module to suggest additional inspection plans and corrections. The emotion engine adjusts the suggestions based on the user's emotional state.

[1392] 6. Response Generation:

[1393] The server automatically generates a response based on the reviewer's comments and sends it to the user. The emotion engine adjusts the tone and style of the response based on the user's emotional state. The user can then review and edit the response before sending it to the reviewer.

[1394] Device:

[1395] 1. Data Entry:

[1396] Users upload document files and enter inspection history through their terminals, which then send this data to the server.

[1397] 2. Confirmation of potential evaluation targets:

[1398] The server sends a list of potential rating recipients to the user's device, and the user selects the most appropriate one. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1399] 3. Download the fix:

[1400] The user can download the document that has been formatted and grammar corrected through the terminal.

[1401] 4. Provide reviewer comments:

[1402] After resubmission, the user sends the comments received from the reviewer from their device to the server, where the emotion recognition function analyzes the user's emotional state and sends the results to the server.

[1403] 5. Check the response:

[1404] The response sent from the server is displayed on the device, and the user can check and edit it before sending it to the reviewer. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1405] Specific examples

[1406] When a company's security officer submits "Security Policy.pdf" to the server, the server receives the document and its inspection history and begins analysis. Based on the document's content and past inspection history, the generative AI model suggests "Assessment Agency A," "Assessment Agency B," and "Assessment Agency C" as potential evaluation candidates. The emotion engine analyzes the user's stress level and, if stress levels are high, emphasizes the suggestion of "Assessment Agency B," which has a faster evaluation process. The officer reviews this on their device and selects "Assessment Agency A." The server then modifies "Security Policy.pdf" according to the formatting specifications of "Assessment Agency A," and the emotion engine adjusts the tone and style of the formatting based on the user's stress level. The grammar proofreading module then scrutinizes grammar, style, and terminology, and the emotion engine adjusts the tone and style. The revised document is provided to the officer for resubmission. After resubmission, the officer receives comments from the reviewers and sends them to the server, which proposes additional inspection plans and creates a response to the reviewer using the response generation module. The emotion engine adjusts the suggestion content and tone of the response based on the user's emotional state. In this way, personnel can quickly and efficiently evaluate and revise security policies.

[1407] Example prompts for generative AI models

[1408] "Analyze the security audit report and answer the following questions:

[1409] 1. Which of the security measures you have implemented are weak? Which areas need improvement?

[1410] 2. What are the recommended measures to address the identified risks?

[1411] 3. What message should you convey to users? Tailor your suggestions to them, especially considering their stress levels.

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

[1413] Step 1:

[1414] The user uses a terminal to upload a document file (e.g., "SecurityPolicy.pdf") and inspection history. The terminal sends this data to the server. The server receives the document file and inspection history and stores them in a database. The input data is the document file and inspection history, and the output data is a notification that the data has been successfully saved to the database.

[1415] Step 2:

[1416] The server uses a generative AI model to analyze the saved document file and inspection history. The input data is the document file and inspection history, and the output data is the analysis results, which are evaluation destination candidates (e.g., "Evaluation Agency A," "Evaluation Agency B," "Evaluation Agency C"). The generative AI model analyzes the document content and performs the process of suggesting the most suitable evaluation destination.

[1417] Step 3:

[1418] The server uses an emotion engine to analyze the user's emotional state at the time of upload. The input data for emotion recognition is the user's facial expressions and voice data, and the output data is the analyzed emotional state (e.g., stress level). The suggestions are adjusted based on the analysis results.

[1419] Step 4:

[1420] The server sends the candidate evaluation destinations to the terminal. The terminal displays them to the user, who selects the most suitable evaluation destination. Information on the selected evaluation destination is sent to the server. The input data is the candidate evaluation destinations, and the output data is the selected evaluation destination.

[1421] Step 5:

[1422] The server obtains the format specification of the selected evaluation target and automatically converts the document file to the specified format. The input data is the document file and the format specification, and the output data is the document file after formatting correction. The server uses the format correction module to adjust the tone and style based on the emotion engine.

[1423] Step 6:

[1424] The server uses a grammar correction module to check the formatted document file for appropriate grammar, style, and terminology, and makes any necessary corrections. The input data is the formatted document file, and the output data is the grammar-corrected document file. The emotion engine adjusts the tone and style of the proofreading. The proofread document file is then sent to the terminal, ready for the user to download.

[1425] Step 7:

[1426] The user uses a terminal to check the document file after formatting and grammar correction has been completed and resubmit it. The server receives the resubmitted document file along with the reviewer comments. The input data is the document file and the reviewer comments, and the output data is a notification of successful upload to the server.

[1427] Step 8:

[1428] The server uses the reviewer comment analysis module to analyze the reviewer comments and propose additional inspection plans and corrections. The input data is the reviewer comments, and the output data is the proposed additional inspection plans and corrections. The analysis results are sent to the terminal and displayed to the user.

[1429] Step 9:

[1430] The server uses a response generation module to automatically generate responses based on reviewer comments. The input data is the reviewer comments, and the output data is the generated response. The emotion engine adjusts the tone and style of the response. The generated response is sent to the device, where the user can review and edit it.

[1431] Step 10:

[1432] The user uses a terminal to check the generated response, make any necessary corrections, and send it to the reviewer. The input data is the generated response and any user corrections, and the output data is the final response. This process allows the user to efficiently evaluate security policies and audit reports and respond to reviewer comments.

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

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

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

[1436] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1450] To implement the present invention, it is necessary to configure a system and execute a program as follows.

[1451] System configuration

[1452] server:

[1453] The server contains a generative AI model, a database, a formatting correction module, an English proofreading module, a reviewer comment analysis module, and a response generation module. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the user's device.

[1454] Device:

[1455] The terminal provides an interface where users can upload their paper files, enter their submission history, and check the server's suggestions and corrections. The terminal also supports data communication between the user and the server.

[1456] User:

[1457] As a researcher, users manage the paper submission process through their devices: submitting paper files, selecting potential publication destinations, reviewing and resubmitting revised and proofread papers, and responding to comments from reviewers.

[1458] Program processing explanation

[1459] server:

[1460] 1. Receiving your manuscript and submission history:

[1461] The server stores the submitted paper files and submission history in a database, and the stored data is then analyzed.

[1462] 2. Suggestions for potential publications:

[1463] The server uses the generative AI model to analyze the content of the paper and its submission history, compiles a list of suitable submission candidates, and sends it to the user's device.

[1464] 3. Formatting corrections:

[1465] When a user selects a submission destination, the server retrieves the formatting specifications of that destination and automatically converts the paper file into the specified format.

[1466] 4. English Proofreading:

[1467] The English proofreading module on the server checks the corrected format of the paper file for appropriate grammar, style, and terminology, and makes any necessary corrections.

[1468] 5. Reviewer Comment Analysis:

[1469] When a user resubmits or reviews a review, they send the reviewer comments they received to the server, which then uses a comment analysis module to suggest additional experiment plans or corrections.

[1470] 6. Response Generation:

[1471] The server automatically generates a response based on the reviewer's comments and sends it to the user, who then checks and edits it before sending it back to the reviewer.

[1472] Device:

[1473] 1. Data Entry:

[1474] Users upload their paper files and enter their submission history through their terminals, which then send this data to the server.

[1475] 2. Check potential publications:

[1476] The candidate posting destinations sent from the server are displayed on the terminal, and the user selects the most suitable posting destination.

[1477] 3. Download the fix:

[1478] Users will be able to download papers that have been formatted and proofread through their terminals.

[1479] 4. Provide reviewer comments:

[1480] After reposting, the user sends the comments received from the reviewer from the terminal to the server.

[1481] 5. Check the response:

[1482] The response sent from the server is displayed on the terminal, and the user checks and corrects it before sending it to the reviewer.

[1483] Specific examples

[1484] When Dr. A submits "sample_paper.pdf" to the server, the server receives the paper and its submission history and begins analysis. Based on the paper's content and past submission history, the generative AI model suggests "Journal A," "Journal B," and "Journal C" as possible publication destinations. Dr. A reviews this on his device and selects "Journal A." The server then edits "sample_paper.pdf" in accordance with Journal A's formatting specifications and scrutinizes the text using the English proofreading module. The server then provides the revised paper to Dr. A for resubmission. After resubmission, Dr. A receives comments from reviewers and sends them to the server, which then proposes additional experimental plans and creates responses to the reviewers using the response generation module. In this way, Dr. A can quickly and efficiently resubmit or revise his paper.

[1485] The processing flow will be explained below.

[1486] Step 1:

[1487] Users upload their paper files and enter their submission history using their terminals. Once the data is complete, it is sent to the server.

[1488] Step 2:

[1489] The server receives the paper files and submission history sent by the user and stores this data in a database. After storing it, it prepares it for analysis.

[1490] Step 3:

[1491] The server uses the generated AI model to analyze the contents of the paper file and the submission history. Based on the analysis results, it creates a list of optimal submission candidates and sends it to the user's device.

[1492] Step 4:

[1493] The terminal displays the list of candidate posting destinations sent from the server, and provides an interface that allows the user to check this list.

[1494] Step 5:

[1495] The user checks the list of possible posting destinations on the device and selects the most suitable destination. The selected information is sent to the server.

[1496] Step 6:

[1497] The server retrieves the formatting requirements of the submission destination selected by the user from the database, automatically corrects the format of the paper file to conform to those requirements, generates the corrected file, and sends it to the user's device.

[1498] Step 7:

[1499] The terminal displays the formatted paper file sent from the server and provides the user with a downloadable link.

[1500] Step 8:

[1501] The user downloads the corrected formatted paper and checks its contents.

[1502] Step 9:

[1503] The server then runs the revised paper file through the English proofreading module, checking for appropriate grammar, style, and terminology, making any necessary corrections, and generates a proofread file that is sent to the user's device.

[1504] Step 10:

[1505] The terminal displays the proofread paper for the user to review and download.

[1506] Step 11:

[1507] The user checks the edited paper and resubmits it.

[1508] Step 12:

[1509] The user inputs the comments received from the reviewer after reposting into the terminal and transmits them to the server.

[1510] Step 13:

[1511] The server receives the reviewer comments, analyzes them using the generation AI, proposes necessary additional experiment plans and corrections, and sends the results to the user's device.

[1512] Step 14:

[1513] The terminal displays the additional experiment plan and modifications sent from the server, and provides an interface for the user to check them.

[1514] Step 15:

[1515] The user checks the proposal and makes any necessary corrections or additional experiments.

[1516] Step 16:

[1517] The server automatically generates a response based on the reviewer's comments and sends it to the user's device, allowing the user to check, modify, and submit the response.

[1518] Step 17:

[1519] The user checks and edits the response and sends it to the reviewer.

[1520] In this way, the system supports users in efficiently resubmitting papers and responding to reviewers.

[1521] Example 1

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

[1523] Traditionally, the paper submission process required researchers to manually perform a wide range of tasks, including selecting a journal to submit to, formatting, proofreading, and responding to reviewer comments, which required a great deal of time and effort. The process of selecting a journal and formatting was particularly complex and prone to errors. It was also difficult to find an appropriate response to reviewer comments. To solve these issues, an automated system is needed.

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

[1525] In this invention, the server includes means for receiving a paper file and submission history from a user, means for analyzing the received paper file and submission history and using a generative AI model to suggest optimal submission destination candidates, means for automatically correcting the format of the paper file to conform to the specifications of the suggested submission destinations, means for proofreading the corrected paper file, means for analyzing reviewer comments received by the user after resubmission and suggesting additional experimental plans and corrections, and means for automatically generating replies to reviewers. This streamlines the paper submission process, reduces the workload on researchers, and improves the success rate of submissions.

[1526] A "paper file" refers to a document that summarizes research results and considerations submitted by a user, and is saved in a format such as a PDF or text file.

[1527] "Submission history" refers to information that records the journals to which a user has submitted papers, the results, and the feedback they received.

[1528] A "generative AI model" refers to an algorithm that uses artificial intelligence to analyze user input data and suggest potential posting destinations.

[1529] "Formatting" refers to the process of automatically adjusting page layout, fonts, citation style, etc. of a paper file in accordance with the specified submission guidelines.

[1530] "Proofreading" refers to the process of checking and correcting English grammar, style, and vocabulary for accuracy.

[1531] "Reviewer comments" refers to the feedback and evaluation provided by a journal's reviewers on a paper.

[1532] "Additional experimental plan" refers to a plan for experiments or research activities that should be added to the paper, suggested based on reviewer comments.

[1533] "Revisions" refer to the parts or content in the paper that need to be revised based on reviewer comments.

[1534] A "response" refers to a text that summarizes a user's response or rebuttal to a comment received from a reviewer.

[1535] To implement the present invention, it is necessary to configure a system and execute a program as follows.

[1536] System configuration

[1537] server:

[1538] The server contains a generative AI model, a database, a formatting correction module, an English proofreading module, a reviewer comment analysis module, and a response generation module. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the users' devices.

[1539] Device:

[1540] The terminal provides an interface for users to upload paper files, enter their submission history, and check the server's suggestions and corrections. The terminal also supports data communication between the user and the server.

[1541] User:

[1542] As a researcher, users manage the paper submission process through their devices: submitting paper files, selecting potential publication destinations, reviewing and resubmitting revised and proofread papers, and responding to comments from reviewers.

[1543] Program processing explanation

[1544] server:

[1545] The server stores the submitted paper files and submission history in a database, which is then analyzed by a generative AI model.

[1546] The server uses a generative AI model to analyze the content of the paper and its submission history, compiles a list of suitable submission candidates, and sends it to the user's device.

[1547] When a user selects a submission destination, the server retrieves the formatting specifications of that destination and automatically converts the paper file into the corresponding format.

[1548] The English proofreading module on the server checks the corrected paper file for appropriate grammar, style, and terminology, and makes any necessary corrections.

[1549] When a user resubmits or reviews a review, the reviewer comments received are sent to the server, where they are analyzed using a comment analysis module, which then proposes additional experimental plans and corrections.

[1550] The server automatically generates a response based on the reviewer's comments and sends it to the user, who then checks and corrects it and sends it back to the reviewer.

[1551] Device:

[1552] Users upload their paper files and enter their submission history via their terminals, and this data is sent to the server.

[1553] The candidate posting destinations sent from the server are displayed on the terminal, and the user selects the most suitable posting destination.

[1554] The terminal provides the paper with formatting correction and English proofreading completed so that the user can download the corrected paper.

[1555] After reposting, the user sends the comments received from the reviewer from the terminal to the server.

[1556] The response sent from the server is displayed on the terminal, and the user checks and corrects it before sending it to the reviewer.

[1557] Specific examples

[1558] When Dr. A submits "sample_paper.pdf" to the server via his / her device, the server receives the paper file and submission history and stores them in a database. Next, it uses a generative AI model to analyze the paper content and submission history, suggesting potential publication destinations such as "Journal A," "Journal B," and "Journal C." This information is then sent to the user's device. When Dr. A selects "Journal A" on his / her device, the server modifies "sample_paper.pdf" based on the formatting specifications of that publication. The English proofreading module then checks grammar and style and makes any necessary corrections. The revised paper is then provided to the user's device, where Dr. A can review and resubmit it. After resubmission, Dr. A receives comments from the reviewers and sends them from his / her device to the server. The server analyzes the comments and suggests additional experimental plans and revisions. The response generation module then generates a response to the reviewer and sends it to Dr. A. Dr. A reviews and edits the response and finally sends it to the reviewer.

[1559] Prompt Sentence Examples

[1560] "Please explain how the server formats the paper."

[1561] "Please explain specifically how to use a generative AI model to suggest potential posting destinations."

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

[1563] Step 1:

[1564] The user uses the terminal to upload the paper file (e.g., "sample_paper.pdf") and submission history. This becomes the input data. The terminal then sends this data to the server. Specifically, the system transfers the file specified by the user to the server using the system's upload function.

[1565] Step 2:

[1566] The server receives the paper file and submission history data sent from the terminal and stores them in a database. This data becomes input data. The specific operations performed by the server include storing the received file in the appropriate table in the database and, if necessary, verifying the integrity of the data.

[1567] Step 3:

[1568] The server uses a generative AI model to analyze the saved paper files and submission history. The input data are the saved paper files and submission history. As a result of the analysis, the server generates a list of suitable submission candidates (e.g., "Journal A," "Journal B," "Journal C"), which becomes the output. Specifically, the generative AI model analyzes the content of the uploaded paper based on the content and past submission history, and then recommends appropriate journals.

[1569] Step 4:

[1570] The server sends the generated list of candidate destinations to the user's terminal. The input data is the generated list of candidate destinations, and the output is the data sent to the user's terminal. Specifically, the server performs a data transfer process to notify the user's terminal of an appropriate list of candidate destinations.

[1571] Step 5:

[1572] The user checks the list of suggested posting destinations on the device and selects the most suitable posting destination from among them (e.g., "Journal A"). The input data is the list of candidate posting destinations, and the output is the selected posting destination. Specifically, the user operates the device interface to perform operations such as clicking a selection button.

[1573] Step 6:

[1574] The server obtains the journal specifications selected by the user and automatically formats the paper file accordingly. The input data is the selected journal and the original paper file, and the output is the formatted paper file. Specifically, the server obtains the format specifications of the journal and automatically adjusts the uploaded paper to comply with those specifications.

[1575] Step 7:

[1576] The server applies the English proofreading module to the paper file after formatting correction is complete. The input data is the paper file after formatting correction, and the output is the proofread paper file. Specifically, the English proofreading module checks the appropriateness of grammar and vocabulary and makes any necessary corrections.

[1577] Step 8:

[1578] The server sends the proofread paper file to the user's terminal. The input data is the proofread paper file, and the output is the revised paper file sent to the terminal. Specifically, the server performs data communication processing to transfer the proofread paper file to the user's terminal.

[1579] Step 9:

[1580] The user checks the revised paper file on their device and resubmits it. The input data is the proofread paper file, and the output is the resubmitted paper file. Specifically, the user checks the revised text on their device and then goes through the process of resubmitting it to the journal's submission site.

[1581] Step 10:

[1582] The user sends the reviewer comments received after reposting from the terminal to the server. The input data is the reviewer comments, and the output is the reviewer comments sent to the server. Specifically, the user uploads a file of review comments and sends it to the server.

[1583] Step 11:

[1584] The server uses a reviewer comment analysis module to analyze the received comments and propose additional experiment plans and modifications. The input data are reviewer comments, and the output is proposals as the analysis results. Specifically, the comment analysis module analyzes the comment content and lists recommended experiment plans and modifications.

[1585] Step 12:

[1586] The server automatically generates a response based on the reviewer's comments and sends it to the user. The input data is the analyzed reviewer's comments, and the output is the generated response. Specifically, the response generation module automatically creates an appropriate response based on the analysis results and sends it to the terminal.

[1587] Step 13:

[1588] The user checks and corrects the response on the device and sends it to the reviewer. The input data is the generated response, and the output is the corrected response. Specifically, the user checks the response on the device, makes any necessary corrections, and then sends it to the reviewer.

[1589] (Application example 1)

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

[1591] Currently, quality control processes in factories require a lot of manual work and time, resulting in problems such as reduced efficiency and the risk of human error. Furthermore, analyzing feedback and proposing improvement measures relies on experience and expertise, which can lead to a lack of consistency. Therefore, there is a need to automate and streamline these processes.

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

[1593] In this invention, the server includes means for receiving a paper file and submission history from a user, means for analyzing the received paper file and submission history to suggest optimal submission destination candidates, means for automatically correcting the format of the paper file to conform to the specifications of the suggested submission destination, means for proofreading the paper file, means for analyzing comments from reviewers to suggest additional experiment plans and corrections, means for automatically generating a quality control report, means for automatically correcting the generated report to a specified format, means for analyzing feedback and identifying areas for improvement, means for proposing improvement measures based on the areas for improvement, and means for automatically generating a response to the reviewer. This automates the quality control process within the factory, enabling efficient and consistent analysis of feedback and proposal of improvement measures.

[1594] "User" means a person or organization that uses the system to manage the manuscript submission process and quality control process.

[1595] A "paper file" is a digital document of an academic paper written by a researcher.

[1596] A "submission history" is a record of which journals and academic publications a researcher has submitted papers to in the past.

[1597] "Analysis" is the process of converting input data into meaningful information.

[1598] The "best publication candidates" are a list of academic journals and journals suitable for submitting a paper, suggested based on the analysis results.

[1599] "Formatting" is the process of automatically changing the format of a paper file according to certain rules.

[1600] "English proofreading" is the process of checking English texts for appropriate grammar, style, and terminology, and making any necessary corrections.

[1601] "Reviewer comments" are evaluations and feedback given by reviewers of a paper on its content.

[1602] "Additional Experiment Plan" is a plan for additional experiments that are proposed based on reviewer comments.

[1603] "Revisions" are the specific changes needed to improve the paper based on reviewer comments.

[1604] A "response" is a written response or reply made by a researcher to a reviewer's comment.

[1605] A "quality control report" is a document that organizes data on product quality within a factory and reports on the quality status.

[1606] "Feedback" refers to evaluations and comments received from superiors, quality control departments, etc.

[1607] "Improvements" are specific areas for improving a product or process that are identified based on feedback.

[1608] "Improvements" are proposed ways to improve a product or process based on improvements.

[1609] To implement this invention, it is necessary to configure the following system and run the program. The main components of the system are a server, a terminal, and a user. This invention is designed specifically to streamline the quality control process in factories.

[1610] System configuration

[1611] server

[1612] The server contains a generative AI model, a database, a formatting correction module, an English proofreading module, a feedback analysis module, and a module for suggesting improvements. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the terminal.

[1613] Terminal

[1614] The terminal provides an interface for users to upload quality control reports, input feedback, and view suggestions and corrections from the server. The terminal supports data communication between the user and the server.

[1615] User

[1616] As a quality control officer at a factory, the user manages the quality control process through the terminal, submitting quality control reports, inputting feedback, and confirming and implementing corrections and improvements.

[1617] Program processing explanation

[1618] server

[1619] The server stores the quality control reports and feedback received from the devices in a database. A generative AI model automatically generates quality control reports based on data collected from sensors and inspection equipment. During this process, the stored data is analyzed. AI models used include GPT-3 and SpellChecker.

[1620] The server has a format correction module that automatically corrects the generated report into a specified format. If the corrected report is in English, the English proofreading module checks the appropriateness of grammar, style, and terminology and makes any necessary corrections.

[1621] The feedback analysis module analyzes the feedback provided by users and identifies specific areas for improvement. Based on these results, the improvement proposal module generates specific improvement measures and provides them to users. This allows users to efficiently identify and implement improvements to their quality control.

[1622] Terminal

[1623] The terminal provides an interface for users to upload quality control reports and enter feedback. The terminal transmits this data to the server, where the user can check the correction results and improvement suggestions sent by the server. The terminal also makes the generated quality control reports and suggested improvements available for download.

[1624] Specific examples

[1625] For example, suppose a quality control officer at a factory submits a file called "sensor_data.csv" to the server. The server receives the data and uses a generative AI model to automatically generate a quality control report. At that time, the server specifies the format "quality control report" and automatically corrects the format.

[1626] When a user sends feedback received from their superior to the server from their device, the feedback analysis module begins analysis to identify specific areas for improvement. Then, using a generative AI model, it proposes appropriate improvement measures, enabling the person in charge to quickly and efficiently improve their quality control process.

[1627] Prompt Sentence Examples

[1628] "Generate a quality control report based on the data from the sensors in the following format:

[1629] Data Overview

[1630] Problem

[1631] Current measures

[1632] Recommended Improvements

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

[1634] Step 1:

[1635] The user uploads quality control reports and feedback via the terminal and sends them to the server. The input data is the quality control report (e.g., "sensor_data.csv") and feedback, and data is transmitted from the terminal to the server. The output is the uploaded data stored in the server's database.

[1636] Step 2:

[1637] The server stores the received quality control reports in a database. This stored data is then used for analysis. Specifically, the server inserts the data into the database in the appropriate format. The input is the uploaded quality control report data, and the output is the data already stored in the database.

[1638] Step 3:

[1639] The server uses a generative AI model (e.g., GPT-3) to automatically generate a report based on the stored quality control report data. During this process, a prompt is input into the generative AI model, which generates text based on the required data. The input is the quality control report data and the prompt, and the output is the generated quality control report text. An example of a specific prompt is, "Based on data from the sensors, please generate a quality control report in the following format: - Data summary - Problem - Current measures - Recommended improvement measures."

[1640] Step 4:

[1641] The server automatically modifies the generated quality control report to the specified format. It uses a format modification module to convert the data to fit the required layout and format. The input is the generated quality control report text and formatting specifications, and the output is the modified report. Specifically, it adjusts the layout and adds the necessary headers and footers.

[1642] Step 5:

[1643] If the corrected report is in English, the server's English proofreading module checks the grammar, style, and terminology for appropriateness and makes any necessary corrections. The input is the corrected English report, and the output is the proofread report. Specifically, grammar checks and style guide-based corrections are made.

[1644] Step 6:

[1645] The user sends the feedback received from the superior or quality control department from the terminal to the server. The feedback data is used as input, and the server takes the feedback stored in the database. The output is the saved feedback data.

[1646] Step 7:

[1647] The server's feedback analysis module analyzes the feedback provided by users and identifies areas for improvement. The input is the feedback data, and the output is the identified areas for improvement. Specific operations include analyzing the feedback text and performing automatic scoring and keyword extraction.

[1648] Step 8:

[1649] Based on the analysis results, the server's improvement suggestion module generates specific improvement suggestions and provides them to the user. The suggestion text is automatically generated using a generative AI model (e.g., GPT-3). The input is the analysis results and a prompt text, and the output is a suggested improvement text. An example of a specific prompt text is, "Please suggest specific improvement measures based on the feedback below."

[1650] Step 9:

[1651] The user checks the improvement proposals sent from the server on their terminal and implements them as necessary. The input is the improvement proposal, and the output is an executable action plan. Specifically, the process includes the actions of checking the proposals and formulating an implementation plan.

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

[1653] To implement the present invention, it is necessary to configure a system and execute a program as follows.

[1654] System configuration

[1655] server:

[1656] The server contains a generative AI model, database, formatting correction module, English proofreading module, reviewer comment analysis module, response generation module, and emotion engine. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the user's device.

[1657] Device:

[1658] The terminal provides an interface where users can upload their paper files, enter their submission history, and check the server's suggestions and corrections. The terminal also supports data communication between the user and the server. Furthermore, the terminal also provides an interface with emotion recognition functionality for analyzing the user's emotional state.

[1659] User:

[1660] As a researcher, users manage the paper submission process through their devices: they submit paper files, select potential publication destinations, review and resubmit revised and proofread papers, respond to reviewers' comments, and communicate their emotional state to the system through emotion recognition.

[1661] Program processing explanation

[1662] server:

[1663] 1. Receiving your manuscript and submission history:

[1664] The server stores the submitted paper files and submission history in a database, and then prepares them for analysis.

[1665] 2. Suggestions for potential publications:

[1666] The server uses a generative AI model to analyze the content of the paper and the submission history, and then creates a list of suitable submission candidates and sends it to the user's device. The emotion engine recognizes the user's emotional state and adjusts the suggestions accordingly.

[1667] 3. Formatting corrections:

[1668] Once a user selects a submission destination, the server retrieves the destination's formatting requirements and automatically converts the manuscript file into the specified format. An emotional engine adjusts the tone and style of the formatting based on the user's emotional state.

[1669] 4. English Proofreading:

[1670] The server-based English proofreading module checks the formatted manuscript file for appropriate grammar, style, and terminology, and makes any necessary corrections. The emotional engine adjusts the tone and style of the proofreading based on the user's emotional state.

[1671] 5. Reviewer Comment Analysis:

[1672] When a user resubmits or reviews a piece of content, they send the reviewer comments they received to the server, which then uses a comment analysis module to suggest additional experiment plans or corrections. The emotion engine adjusts the suggestions based on the user's emotional state.

[1673] 6. Response Generation:

[1674] The server automatically generates a response based on the reviewer's comments and sends it to the user. The emotion engine adjusts the tone and style of the response based on the user's emotional state. The user can then review and edit the response before sending it to the reviewer.

[1675] Device:

[1676] 1. Data Entry:

[1677] Users upload their paper files and enter their submission history through their terminals, which then send this data to the server.

[1678] 2. Check potential publications:

[1679] The server sends a list of potential posting destinations to the device, and the user selects the most appropriate one. The emotion recognition function analyzes the user's emotional state and sends the results to the server.

[1680] 3. Download the fix:

[1681] Users will be able to download papers that have been formatted and proofread through their terminals.

[1682] 4. Provide reviewer comments:

[1683] After reposting, the user sends the comments received from the reviewer from their device to the server, where the emotion recognition function analyzes the user's emotional state and sends it to the server.

[1684] 5. Check the response:

[1685] The response sent from the server is displayed on the device, and the user can check and edit it before sending it to the reviewer. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1686] Specific examples

[1687] When Dr. A submits "sample_paper.pdf" to the server, the server receives the paper and its submission history and begins analysis. Based on the paper's content and past submission history, the generative AI model suggests "Journal A," "Journal B," and "Journal C" as possible submission destinations. The emotion engine analyzes the user's stress level and, if stress levels are high, emphasizes the suggestion of "Journal B," which has a faster review process. Dr. A confirms this on his device and selects "Journal A." The server then edits "sample_paper.pdf" according to "Journal A's" formatting specifications, and the emotion engine adjusts the tone and style of the formatting based on the user's stress level. The English proofreading module then examines grammar, style, and terminology, and the emotion engine adjusts the tone and style accordingly. The revised paper is then provided to Dr. A for resubmission. After resubmission, Dr. A receives comments from reviewers and sends them to the server, which then proposes additional experimental plans and creates a response to the reviewers using the response generation module. The emotion engine adjusts the tone of suggestions and responses based on the user's emotional state, allowing Dr. A to quickly and efficiently resubmit or revise his paper.

[1688] The processing flow will be explained below.

[1689] Step 1:

[1690] The user uploads the paper file using a terminal and enters the submission history. Once the input is complete, the data is sent to the server by pressing the send button.

[1691] Step 2:

[1692] The server receives the submitted paper files and submission history from users and stores this data in a database. After storing the data, it begins preparation for analysis.

[1693] Step 3:

[1694] The server uses the generated AI model to analyze the content of the paper file and the submission history. At the same time, the emotion engine analyzes the user's emotional state data obtained from the device. This allows it to create a list of optimal submission candidates and adjust the suggestions according to the user's emotional state.

[1695] Step 4:

[1696] The server sends a list of suggested posting destinations to the user's device, with the list containing candidates prioritized based on the user's emotional state.

[1697] Step 5:

[1698] The terminal displays a list of candidate posting destinations sent from the server, and provides an interface that allows the user to review the list and select the most suitable posting destination.

[1699] Step 6:

[1700] The user checks the list of potential posting destinations on the device and selects the most suitable one. After selection, the selection information is sent to the server.

[1701] Step 7:

[1702] The server retrieves the formatting requirements of the user's chosen submission destination from a database and automatically formats the manuscript file to conform to those requirements. An emotional engine adjusts the tone and style of the formatting based on the user's emotional state.

[1703] Step 8:

[1704] The server generates a formatted paper file and sends it to the user's terminal.

[1705] Step 9:

[1706] The terminal displays the formatted paper file sent from the server and provides the user with a downloadable link.

[1707] Step 10:

[1708] The user downloads the corrected formatted paper and checks its contents.

[1709] Step 11:

[1710] The server runs the revised paper file through an English proofreading module, checking for appropriate grammar, style, and terminology and making any necessary corrections. An emotional engine adjusts the tone and style of the proofreading based on the user's emotional state.

[1711] Step 12:

[1712] The server generates a proofread paper file and sends it to the user's device.

[1713] Step 13:

[1714] The device will display the proofread paper and provide a link for the user to view and download.

[1715] Step 14:

[1716] The user reviews the proofread paper and, if they determine that no revisions are necessary, resubmits the paper. After resubmission, they receive comments from reviewers.

[1717] Step 15:

[1718] The user inputs the comments received from the reviewer into the device and sends them to the server. The emotion recognition function analyzes the user's emotional state and sends that data to the server.

[1719] Step 16:

[1720] The server receives reviewer comments, analyzes them using generative AI and an emotion engine, and sends them to the user, proposing additional experiment plans and modifications based on the user's emotional state.

[1721] Step 17:

[1722] The terminal displays the additional experiment plan and corrections sent from the server. The user checks this and performs any necessary corrections or additional experiments.

[1723] Step 18:

[1724] The server automatically generates a response based on the reviewer's comments and sends it to the user's device, adjusting the tone and style of the response based on the user's emotional state.

[1725] Step 19:

[1726] The device displays the response sent from the server, and the user can check and correct it before sending it to the reviewer.

[1727] In this way, the system helps users efficiently resubmit their manuscripts and respond to reviewers, and it also adjusts suggestions, formatting, proofreading, and responses taking into account the user's emotional state.

[1728] Example 2

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

[1730] Researchers face a wide range of challenges in the process of submitting academic papers. These include gathering information to select the appropriate publication, the complexity of submission formats, the burden of proofreading, and writing appropriate responses to reviewer comments. These tasks require time and effort, which increases researchers' stress. Furthermore, the impact of researchers' emotional state on these processes cannot be ignored. Conventional systems do not provide comprehensive solutions to these challenges.

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

[1732] In this invention, the server includes means for receiving a research result file and history information from a user, means for analyzing the received research result file and history information to suggest optimal candidate submission destinations, means for automatically correcting the format of the research result file to conform to the specifications of the suggested submission destinations, means for translating and correcting the research result file, means for analyzing comments from evaluators to suggest additional experimental plans and corrections, means for automatically generating responses to the evaluators, and means for analyzing the user's emotional state using an emotion analysis engine and adjusting the tone and style of each process, thereby enabling users to complete the paper submission process quickly and efficiently and reducing their mental burden.

[1733] "User" refers to the researcher or contributor who uses this system and is responsible for uploading research result files, selecting the submission destination, and responding to reviewer comments.

[1734] "Research result files" refer to academic papers and research reports uploaded to this system, and are documents that are subject to formatting correction and translation proofreading.

[1735] "History information" refers to information on past submission history and accepted papers, and is information that serves as reference data when proposing potential next submission destinations.

[1736] "Server" refers to a computer system that analyzes data received from users, suggests suitable submission candidates, and automatically performs formatting corrections and translation proofreading.

[1737] "Candidate submission destinations" refers to the most suitable academic journals or academic societies to which the paper should be submitted, as suggested by the server after analyzing the research results file and historical information.

[1738] "Format correction" refers to the act of automatically changing the format of a research results file in accordance with the regulations of the potential recipient.

[1739] "Translation correction" refers to the process of checking research files for appropriate grammar, style, and terminology and making any necessary corrections.

[1740] "Evaluator opinions" refer to comments and feedback provided by reviewers during the paper review process that may require additional experimental design or suggested revisions.

[1741] "Additional experimental plans" refer to plans for new experiments or surveys proposed based on the evaluator's opinions.

[1742] A "response" refers to a piece of writing written in response to the evaluator's comments, and includes revisions to the paper and supplementary explanations.

[1743] "Emotion analysis engine" refers to artificial intelligence that analyzes the user's emotional state and adjusts the tone and style of each interaction.

[1744] In order to implement the present invention, it is necessary to configure the following system and execute the program.

[1745] System configuration

[1746] server:

[1747] The server contains a generative AI model, database, format correction module, translation correction module, evaluator opinion analysis module, response generation module, and sentiment analysis engine. This server is responsible for receiving input from users, performing the necessary processing, and sending the results to the user's device.

[1748] Device:

[1749] The terminal provides an interface where users can upload research files, input history information, and check suggestions and corrections from the server. The terminal also supports data communication between the user and the server. It also provides an interface with emotion recognition functionality to analyze the user's emotional state.

[1750] User:

[1751] As a researcher, users manage the process of submitting research files through their devices. Specifically, they submit research files, select potential recipients, review and resubmit revised and proofread files, respond to comments from reviewers, and communicate their emotional state to the system through emotion recognition.

[1752] Program processing explanation

[1753] server:

[1754] 1. Receiving thesis and historical information:

[1755] The server stores the research result files and history information sent by users in a database, and then prepares them for analysis.

[1756] 2. Suggestions for potential recipients:

[1757] The server uses a generative AI model to analyze the content and history of research file files, and lists suitable submission candidates. An emotion analysis engine recognizes the user's emotional state and adjusts the suggestions accordingly.

[1758] 3. Format correction:

[1759] Once a user selects a submission destination, the server retrieves the destination's specifications and automatically formats the research file into the specified format. A sentiment analysis engine adjusts the tone and style of the format based on the user's emotional state.

[1760] 4. Translation corrections:

[1761] The server's translation correction module checks the formatted research file for appropriate grammar, style, and terminology, and makes any necessary corrections. The sentiment analysis engine adjusts the tone and style of the corrections based on the user's emotional state.

[1762] 5. Analysis of evaluator opinions:

[1763] When a user resubmits or reviews a review, the user sends the evaluator's comments to the server, which uses the opinion analysis module to suggest additional experiment plans or modifications. The sentiment analysis engine adjusts the suggestions based on the user's emotional state.

[1764] 6. Response Generation:

[1765] The server automatically generates a response based on the evaluator's opinion and sends it to the user. The sentiment analysis engine adjusts the tone and style of the response based on the user's emotional state. The user then checks and edits the response and sends it back to the evaluator.

[1766] Device:

[1767] 1. Data Entry:

[1768] Users upload research result files and enter history information through their terminals, which then send this data to the server.

[1769] 2. Confirm potential recipients:

[1770] The server sends a list of possible submission destinations to the user, which are then displayed on the device, allowing the user to select the most appropriate one. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1771] 3. Download the fix:

[1772] Users will be able to download research result files that have been formatted and translated via their terminals.

[1773] 4. Providing reviewer feedback:

[1774] After reposting, the user sends the feedback received from the reviewers from their device to the server. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1775] 5. Check the response:

[1776] The response sent from the server is displayed on the device, and the user confirms and corrects it before sending it to the evaluator. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1777] Specific operation example

[1778] When a researcher submits "sample_paper.pdf" to the server, the server begins analyzing the research results file and history information. The generative AI model analyzes the contents of the research results file and, based on past history information, suggests possible submission destinations such as "Journal A," "Journal B," and "Journal C." The sentiment analysis engine analyzes the user's emotional state and, for example, if stress is high, emphasizes the suggestion of "Journal B," which has a quick review process. The researcher confirms this on their device and selects "Journal A."

[1779] The server then edits "sample_paper.pdf" according to the formatting specifications of "Journal A," and a sentiment analysis engine adjusts the tone and style of the format based on the user's stress level. The translation correction module then examines grammar, style, and terminology, and the sentiment analysis engine adjusts the tone and style. The revised research output file is then provided to the researcher, who is then encouraged to resubmit.

[1780] After resubmitting, researchers receive comments from evaluators and send them to the server. The server then uses a comment analysis module to propose additional experimental plans and a response generation module to create a response to the evaluators. An emotion analysis engine adjusts the content of the proposal and the tone of the response based on the user's emotional state. In this way, researchers can quickly and efficiently resubmit their research results and respond to evaluator comments.

[1781] Examples of prompts:

[1782] Please explain the process of a researcher submitting a research result file to a server. Please also explain the process of the server accepting the research result file, analyzing it, suggesting suitable submission destinations, and correcting the format and translation based on emotion recognition. Also, please explain the process of generating a response to a comment.

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

[1784] Step 1:

[1785] Receiving papers and historical information

[1786] Input: The user uses the terminal to upload the research output file (e.g., "sample_paper.pdf") and history information (e.g., past submission history).

[1787] Specific operation: The terminal receives the research result file and history information provided by the user and transmits this data to the server.

[1788] Output: The server stores the received data in a database.

[1789] Step 2:

[1790] Suggestions for potential recipients

[1791] Input: Research output files and historical information stored in the server's database.

[1792] How it works: The server uses generative AI models to analyze the content and history of research files, for example, using topic modeling to identify research topics and then lists the best candidates for submission.

[1793] Output: Sends suggested submission candidates (e.g. "Journal A", "Journal B", "Journal C") to the user's device.

[1794] Step 3:

[1795] Format correction

[1796] Input: The submission destination selected by the user (e.g. "Journal A").

[1797] What it does: When a user selects a submission destination, the server retrieves the destination's formatting requirements and automatically formats the research file according to the specified format (e.g., font, paragraph style, citation format, etc.). The sentiment analysis engine adjusts the tone and style of the format based on the user's emotional state.

[1798] Output: Research results file in modified format.

[1799] Step 4:

[1800] Translation fixes

[1801] Input: Research results file in modified format.

[1802] What it does: The server uses a translation correction module to check for appropriate grammar, style, and terminology and make any necessary corrections. The sentiment analysis engine adjusts tone and style based on the user's emotional state.

[1803] Output: Research results file with translation correction completed.

[1804] Step 5:

[1805] Download the fixed version

[1806] Input: Research results file with translation corrections completed.

[1807] Specific operation: The server is configured to provide the modified research result file to the user's terminal, and the user can download the file from the terminal.

[1808] Output: The modified research file downloaded by the user.

[1809] Step 6:

[1810] Providing evaluator opinions

[1811] Input: Input received from reviewers after resubmission (e.g., comments and feedback).

[1812] Specific operation: The user sends the evaluator's opinion from the device to the server. The emotion recognition function analyzes the user's emotional state and sends it to the server.

[1813] Output: Rater opinions and user emotional state data sent to the server.

[1814] Step 7:

[1815] Analysis of evaluator opinions

[1816] Input: Rater opinions and user emotional state data sent to the server.

[1817] Specific operation: The server uses the opinion analysis module to analyze the evaluator's opinions. Based on this, it proposes additional experiment plans and modifications. The sentiment analysis engine adjusts the proposals based on the user's emotional state.

[1818] Output: Suggested additional experimental designs and modifications.

[1819] Step 8:

[1820] Response Generation

[1821] Input: Additional experimental design and modifications based on the reviewer's comments.

[1822] How it works: The server uses a response generation module to automatically generate responses for the evaluator. The sentiment analysis engine adjusts the tone and style of the responses based on the user's emotional state.

[1823] Output: The response sent to the user.

[1824] Step 9:

[1825] Check the response

[1826] Input: The response sent by the server.

[1827] Specific operation: The user checks the response on the device, cor...

Claims

1. a means for receiving paper files and submission histories from users; A method to analyze received paper files and submission history to suggest optimal submission candidates, and A means to automatically reformat manuscript files to conform to the proposed publication requirements, and A means of proofreading thesis files, A means to analyze comments from reviewers and propose additional experimental plans and modifications; A means of automatically generating responses to reviewers, A system including:

2. 10. The system of claim 1, further comprising means for analyzing reviewer comments received from users and suggesting additional experimental plans and modifications.

3. 2. The system according to claim 1, further comprising means for displaying suggested submission destinations to the user and enabling the user to download the paper after formatting has been corrected.

Images