System

Abstract

A system is provided.SOLUTION: A system comprising: a user authentication means; a data collection means for interacting with generative artificial intelligence; a fact checking means; an automatic content generation means; an automatic content proofing means; an automatic layout generation means; an automatic cover design generation means; a final proofing and correction means; and a digital and print file generation means.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] We will create a document that outlines the "problem the invention aims to solve" and the "means for solving the problem."

[0005] Many business owners want to write their autobiographies, but face challenges such as not having the time or experience to write them themselves, the time and financial burden of hiring a ghostwriter, and a lack of connections to publishers, editors, and ghostwriters. This makes it difficult to produce a high-quality autobiography, and many business owners are unable to realize their dream. Furthermore, because traditional methods require a great deal of time and money to produce an autobiography, a fast and efficient method is needed. [Means for solving the problem]

[0006] The present invention provides a system including a user authentication means, a data collection means for interacting with a generation AI, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and editing means, and a digital and print file generation means. Specifically, the system includes a means for collecting details of episodes and events through user interaction and storing them in a database, a fact-checking means using the Internet and an internal database to verify the accuracy of the collected information, and a means for using a generation AI to determine the chapter structure, order, and placement of key episodes in the autobiography and automatically generate content. The system also includes a means for grammar-checking, spelling-checking, and stylistic consistency of the text generated using the automatic proofreading means, making any necessary edits, and generating multiple cover design proposals based on the user's requirements and presenting them to the user. The system also provides a means for a professional editor to perform final proofreading and editing, converting the completed file into a digital format or a print file, uploading the generated autobiography to a publishing platform, and providing a dashboard for monitoring sales. This system enables the rapid and low-cost creation and publication of high-quality autobiographies.

[0007] "User authentication means" refers to procedures and devices for verifying authentication information when a user accesses a system and confirming that the user has legitimate access rights.

[0008] "Generative AI" refers to advanced algorithms and software that have the ability to interact with humans and collect, analyze, and generate information.

[0009] "Data collection means" refers to devices and technologies for collecting necessary information and episodes through dialogue with users and storing them in a database.

[0010] "Fact-checking instruments" are processes and devices for fact-checking by consulting internal databases and the internet to verify the accuracy and reliability of collected information.

[0011] "Automatic content generation means" refers to algorithms and systems that automatically generate text and structure based on collected and fact-checked information.

[0012] "Automatic content proofreaders" are algorithms and software that automatically check and correct the consistency of grammar, spelling, and style of generated text.

[0013] "Automatic layout generation means" refers to technology and systems that automatically generate the visual layout of text and arrange it in a way that makes it easy to read.

[0014] The "automatic cover design generation means" refers to an algorithm and software for automatically generating multiple cover design proposals based on the user's requirements and presenting them to the user.

[0015] "Final proofreading and correction means" refers to the process and equipment used by professional editors to carry out final checks and corrections.

[0016] "Digital and print file generators" are technologies and systems for converting finished content into e-book and print formats.

[0017] Above are the definitions of each important word. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0026] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0039] MODE FOR CARRYING OUT THE INVENTION

[0040] The present invention provides a system including a user authentication means, a data collection means for interacting with a generation artificial intelligence, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, and a digital and print file generation means.

[0041] User Authentication

[0042] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal sends the entered authentication information to the server. The server queries the database for the received authentication information and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session, but if authentication fails, it returns an error message to the terminal.

[0043] Data collection

[0044] Once authentication is complete, the user begins interacting with the generation AI on the interface. The device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time. The server passes the interaction content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated until the necessary information is accumulated. The server saves the interaction log in a database.

[0045] Fact Check

[0046] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by consulting the internet and internal databases. For example, if a user states that "a new product was a big hit in 2005," the generation AI checks that information against external sources. If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-check results and presents the correction suggestion to the user.

[0047] Content Generation

[0048] The server sends a request to the generative AI to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The generative AI analyzes the data and determines the autobiography's chapter structure, order, and placement of key episodes. For example, it generates chapters such as an introduction, career turning points, and a record of successes and failures. The generative AI returns the first draft to the server, which stores it in a database.

[0049] Proofreading and Layout

[0050] The server requests the generation AI and instructs it to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency and makes any necessary corrections. The generation AI then re-layouts the corrected document. The layout includes header file settings, font selection, and column settings. The server saves the completed document and layout in a database.

[0051] Cover creation

[0052] The user inputs the requirements for the cover design into the interface (e.g., "white text on a blue background"). The device sends the user's requirements to the server. The server requests the generation AI to create multiple cover design proposals. The generation AI generates the design proposals and returns them to the server. The server presents the generated design proposals to the user. The user selects their preferred design and sends the selection to the server via the device.

[0053] Final proofreading and polishing

[0054] A professional editor accesses the server using a device to review the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The professional editor incorporates the corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format or a file for printing.

[0055] Publication and Distribution

[0056] The server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server sends a notification of publication completion to the user and the professional editor. If desired, the user has access to a dashboard to monitor the sales status of the published book. The server collects sales data in real time and displays it on the dashboard.

[0057] The above is a detailed description of the embodiment of the present invention. By using this system, an autobiography can be created and published quickly and efficiently.

[0058] The processing flow will be explained below.

[0059] Step 1:

[0060] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal then sends the entered authentication information to the server.

[0061] Step 2:

[0062] The server queries the database for the authentication information it receives and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session. If authentication fails, an error message is returned to the terminal.

[0063] Step 3:

[0064] After authentication is complete, the user begins interacting with the generative AI on the interface, and the device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time.

[0065] Step 4:

[0066] The server passes the dialogue to the AI ​​generator, which then generates relevant and probing questions. The AI ​​then generates the next most appropriate question and sends it to the device.

[0067] Step 5:

[0068] The user enters an answer, which is then sent to the server via the terminal. This process is repeated until all necessary information is accumulated. The server then saves the dialogue log in a database.

[0069] Step 6:

[0070] The server analyzes the collected data and sends a fact-check request to the Generator AI, which then checks the internet and its internal databases to verify the accuracy of the information provided.

[0071] Step 7:

[0072] If there is a contradiction with the confirmed data, the generation AI generates a correction suggestion and returns it to the server, which then updates the fact-checking results in the database and presents the correction suggestion to the user.

[0073] Step 8:

[0074] The server sends a request to the AI ​​to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The AI ​​then determines the chapter structure and order, as well as the placement of key episodes, and generates a first draft.

[0075] Step 9:

[0076] The server requests the AI ​​to perform automatic proofreading, which checks grammar, spelling, and style consistency and makes any necessary corrections.

[0077] Step 10:

[0078] The generative AI then re-layouts the revised document, including header file settings, font selection, and column settings. The server then stores the completed document and layout in a database.

[0079] Step 11:

[0080] The user enters the requirements for the cover design into the interface (e.g., "white text on a blue background"), and the device sends the user's requirements to the server.

[0081] Step 12:

[0082] The server requests the AI ​​to create multiple cover design proposals, which the AI ​​then generates and returns to the server.

[0083] Step 13:

[0084] The server presents the generated design proposals to the user, who then selects the design they prefer and sends the selection to the server via their terminal.

[0085] Step 14:

[0086] A professional editor accesses the server using a terminal to check the generated document, layout, and cover design. The professional editor then performs a final proofread to optimize the document's style and consistency.

[0087] Step 15:

[0088] A professional editor will make the necessary edits and upload the final file to a server, which will then compile the finished file and generate a digital or print format.

[0089] Step 16:

[0090] The server uploads the final file to the publishing platform, and the server sends a notification of publication completion to the user and the professional editor.

[0091] Step 17:

[0092] If desired, users can access a dashboard to monitor the sales status of their published books. The server collects sales data in real time and displays it on the dashboard.

[0093] The above are the steps of the specific processing flow of the program.

[0094] Example 1

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

[0096] The traditional autobiography creation process is laborious, time-consuming, and often requires specialized knowledge. As a result, individuals who try to create their own autobiographies face many difficulties. To solve this problem, a system is needed to create and publish autobiographies efficiently and quickly by automating each step, including data collection, fact-checking, content creation, proofreading, layout, cover design, final proofreading, and digital and print file creation.

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

[0098] In this invention, the server includes a user authentication means, a data collection means for interacting with the generation AI, and a fact-checking means for analyzing the collected data and checking the authentication information, thereby enabling efficient user authentication and highly reliable data collection and verification.

[0099] "User authentication means" is a means for verifying that a user is a legitimate user when accessing a system.

[0100] The "data collection means for interacting with the generative artificial intelligence" is a means for collecting necessary information through interaction with the user.

[0101] "Fact-checking measures" are measures used to verify the accuracy and veracity of collected data.

[0102] The "automatic content generation means" is a means for automatically generating content based on collected data.

[0103] An "automated content proofreader" is a tool for checking and correcting the consistency of grammar, spelling, and style of generated content.

[0104] The "automatic layout generation means" is a means for automatically generating a page layout based on the proofread content.

[0105] The "automatic cover design generation means" is a means for automatically generating a cover design based on the user's requirements.

[0106] "Final proofreading and correction means" refers to the means for finally checking and correcting the generated content, layout, and cover design.

[0107] "Digital and print file generation means" means for generating the final completed document or design as a digital file and a print file.

[0108] The present invention is a system including a user authentication means, a data collection means for interacting with a generation artificial intelligence, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, and a digital and print file generation means. By using this system, users can efficiently create and publish their autobiographies.

[0109] User Authentication

[0110] A user accesses the system's web page using their own PC or smartphone. The terminal displays an interface and the user enters their user ID and password. For example, the user ID is "user123" and the password is "password123." The terminal encrypts this authentication information and sends it to the server. The server queries its database for the received authentication information, and if matching information is found, it generates a session ID and notifies the start of the session.

[0111] Data collection

[0112] After authentication is complete, the user moves to the dialogue interface and begins a dialogue with the generation AI. For example, they might enter, "We entered a new market in 2005." The device sends this input in real time to the server, which then passes it on to the generation AI. The generation AI then generates related and probing questions (e.g., "Which markets did you enter?"), which the server receives and sends to the device. By repeating this process, the necessary information is accumulated, and the dialogue log is stored in a database.

[0113] Fact Check

[0114] The server analyzes the collected data and sends a fact-checking request to the generation AI. For example, to check a claim such as "The new product was a big hit in 2005," the generation AI consults the internet and internal databases. It verifies the information against external sources and, if there is a discrepancy, generates a correction suggestion and sends it to the server. For example, a correction suggestion might be "The new product was a big hit in 2006, not 2005." The server updates the database and notifies the user of the correction suggestion.

[0115] Content Generation

[0116] Once the fact-checking is complete, the server sends a request to the generative AI to create a draft of the autobiography structure based on the collected anecdotes and verified data. The generative AI analyzes the data and determines the chapter structure, such as an introduction, career turning points, and a record of successes and failures. For example, the chapters might be "Introduction," "Career Shift," and "Success Stories." The generative AI creates a first draft and sends it to the server, where it is stored in a database.

[0117] Content proofing and layout

[0118] The server requests the generation AI to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency, and makes any necessary corrections. For example, it adds punctuation to change "successfully" to "successfully." The generation AI then lays out the proofread text. The layout includes header settings, font selection, column settings, etc. The server saves the completed document and layout in a database.

[0119] Cover creation

[0120] The user inputs the requirements for the cover design into the interface. For example, they specify "white text on a blue background." The device sends this to the server, which then requests the AI ​​to generate a cover design proposal. The server receives the generated design proposals and presents them to the user. The user then selects their preferred design and sends the results to the server via the device.

[0121] Final proofreading and polishing

[0122] A professional editor accesses the server via a device to review the generated document, layout, and cover design. A final proofreading is performed to optimize the document's style and consistency. The professional editor incorporates any corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format and a file for printing.

[0123] Publication and Distribution

[0124] The server uploads the final file to a publishing platform, such as an online bookstore, and sends a notification of publication completion to the user and the professional editor. Optionally, the user can access a dashboard to monitor sales of the published book. The server collects sales data in real time and displays it on the dashboard.

[0125] Examples of concrete examples and prompts

[0126] Examples:

[0127] User types, "In 2005, we entered a new market."

[0128] The generative AI generates the question, "Which markets have you expanded into?"

[0129] Fact check example: "The new product became a big hit in 2006, not 2005" generates a correction suggestion.

[0130] Cover design requirements: "White text on a blue background."

[0131] Example prompt sentence:

[0132] "Prompt for user ID and password authentication. Example: User ID = 'user123', Password = 'password123'"

[0133] "A prompt that generates an appropriate question based on user input. Example: User input = 'We entered new markets in 2005'"

[0134] "A prompt that fact-checks information stated by the user. Example: User input = 'A new product became a big hit in 2005.'"

[0135] "A prompt that generates cover design ideas based on user requirements. Example: requirement = 'white text on blue background'"

[0136] The above is a detailed description of the embodiment of the present invention. This system allows users to efficiently create and publish their own autobiographies using advanced AI technology.

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

[0138] Step 1:

[0139] A user accesses the system's web page using their own terminal. The interface is displayed and they enter their user ID and password. Input information:

[0140] User ID (e.g., user123)

[0141] Password (e.g. password123)

[0142] What it does: You enter your user ID and password into a form, which starts the authentication process.

[0143] Step 2:

[0144] The terminal encrypts the entered authentication information and sends it to the server.

[0145] input:

[0146] Encrypted user ID and password

[0147] How it works: Authentication information is transmitted using the HTTPS protocol, which ensures a high level of security.

[0148] Step 3:

[0149] The server queries the database for the authentication information it receives and verifies it.

[0150] input:

[0151] Encrypted user ID and password

[0152] What it does: Runs an SQL query against the database to find records that match the input information.

[0153] output:

[0154] Match result (success or failure)

[0155] Step 4:

[0156] If authentication is successful, the server generates a session ID and notifies the terminal of the start of the session. If authentication fails, the server returns an error message to the terminal.

[0157] input:

[0158] Matching results

[0159] Behavior: Generates a session ID (e.g., ABC123) and generates a session start message or an error message.

[0160] output:

[0161] Session ID or error message

[0162] Step 5:

[0163] After authentication is complete, the user accesses the dialogue interface and begins dialogue with the generated AI.

[0164] input:

[0165] Authentication successful (Session ID)

[0166] Action: A dialog interface is displayed allowing the user to enter information.

[0167] Step 6:

[0168] The user inputs information into the dialogue interface, for example, "We entered a new market in 2005," and the device sends the input to the server.

[0169] input:

[0170] User input (e.g., "We expanded into new markets in 2005")

[0171] Operation: Input information is sent to the server in real time.

[0172] Step 7:

[0173] The server passes the user's input to the generation AI, which generates related and probing questions.

[0174] input:

[0175] User Input

[0176] How it works: The generation AI runs a prompt to generate a question.

[0177] output:

[0178] Generated questions (e.g., "Which markets have you expanded into?")

[0179] Step 8:

[0180] The server receives the questions generated by the generation AI and sends them to the device.

[0181] input:

[0182] Generated Questions

[0183] Action: Sends the question to the terminal and displays it to the user.

[0184] output:

[0185] The question shown to the user

[0186] Step 9:

[0187] The user answers the generated question and the terminal sends the answer back to the server.

[0188] input:

[0189] User response (e.g., "We have expanded into the Asian market")

[0190] Action: Sends the user's answer to the server.

[0191] Step 10:

[0192] This process is repeated until all necessary information is accumulated. The server stores all interaction logs in a database.

[0193] input:

[0194] User Answers

[0195] What it does: Saves the interaction log to a database.

[0196] output:

[0197] Interaction logs stored in a database

[0198] Step 11:

[0199] The server analyzes the collected data and sends a fact-checking request to the generating AI.

[0200] input:

[0201] Data collected

[0202] What it does: Runs a prompt that asks the generating AI to fact-check something.

[0203] output:

[0204] Fact-check request

[0205] Step 12:

[0206] The generating AI will check the internet and internal databases to verify the accuracy of the information provided.

[0207] input:

[0208] Fact-checked data

[0209] What it does: Validates data against external sources.

[0210] output:

[0211] Verification result (correct / incorrect)

[0212] Step 13:

[0213] If there is a discrepancy with the verified data, the generation AI generates correction suggestions and sends them to the server.

[0214] input:

[0215] confirmation result

[0216] Behavior: If there are any conflicts, generate correction suggestions.

[0217] output:

[0218] Revision suggestions

[0219] Step 14:

[0220] The server reflects the fact-check results in the database and notifies the user of suggested corrections.

[0221] input:

[0222] Revision suggestions

[0223] Action: Update the database and notify the user.

[0224] output:

[0225] Notification of proposed amendments

[0226] Step 15:

[0227] The server sends a request to the generation AI to create a draft of the autobiography structure based on the collected episodes and fact-checked data.

[0228] input:

[0229] Episodes and fact-checked data

[0230] Behavior: Executes a prompt to ask the generation AI to create a configuration.

[0231] output:

[0232] Request for composition plan

[0233] Step 16:

[0234] A generative AI analyzes the data and determines the autobiography's chapter structure, order, and placement of key episodes.

[0235] input:

[0236] Request for composition plan

[0237] What it does: Analyzes data and generates configuration suggestions.

[0238] output:

[0239] Chapter structure (e.g., "Introduction," "Career Turning Points," "Record of Successes and Failures")

[0240] Step 17:

[0241] The generative AI sends the initial draft to the server, which stores it in a database.

[0242] input:

[0243] first draft

[0244] What it does: Saves the first draft to the database.

[0245] output:

[0246] Saved first draft

[0247] Step 18:

[0248] The server requests the generation AI to automatically proofread the created text.

[0249] input:

[0250] Saved first draft

[0251] Behavior: Executes a prompt to ask the generating AI to perform auto-calibration.

[0252] output:

[0253] Automatic proofreading request

[0254] Step 19:

[0255] Generative AI checks grammar, spelling, and style consistency, and makes any necessary corrections.

[0256] input:

[0257] first draft

[0258] What it does: Checks and corrects grammar and spelling.

[0259] output:

[0260] Corrected text

[0261] Step 20:

[0262] The generation AI will then re-layout the revised text, setting headers, selecting fonts, and setting columns.

[0263] input:

[0264] Corrected text

[0265] Action: Lays out the text.

[0266] output:

[0267] Layout text

[0268] Step 21:

[0269] The server stores the completed document and layout in a database.

[0270] input:

[0271] Layout text

[0272] What it does: Saves documents and layouts to a database.

[0273] output:

[0274] Saved Documents and Layouts

[0275] Step 22:

[0276] The user enters the cover design requirements into the interface, for example, specifying "white text on a blue background."

[0277] input:

[0278] Cover design requirements

[0279] Action: Enter design requirements into the interface.

[0280] output:

[0281] Design Requirements

[0282] Step 23:

[0283] The terminal sends the user's requirements to the server.

[0284] input:

[0285] Design Requirements

[0286] Action: Sends requirements to the server.

[0287] output:

[0288] Submitted requirements

[0289] Step 24:

[0290] The server requests the generation AI to create a cover design proposal.

[0291] input:

[0292] Submitted requirements

[0293] Action: Prompt the generation AI to create a cover design proposal.

[0294] output:

[0295] Request for cover design proposal

[0296] Step 25:

[0297] The generation AI generates multiple cover design ideas and sends them to the server.

[0298] input:

[0299] Request for cover design proposal

[0300] What it does: Generate multiple design ideas.

[0301] output:

[0302] Design proposal

[0303] Step 26:

[0304] The server presents the generated design proposal to the user.

[0305] input:

[0306] Design proposal

[0307] What it does: Displays design suggestions to the user.

[0308] output:

[0309] The proposed design

[0310] Step 27:

[0311] The user selects a design of their choice and transmits the selection result to the server via the terminal.

[0312] input:

[0313] Design selection results

[0314] Action: Sends the selection results to the server.

[0315] output:

[0316] Submitted selection results

[0317] Step 28:

[0318] A professional editor uses a terminal to access the server and check the generated document, layout, and cover design.

[0319] input:

[0320] Generated document, layout and cover design

[0321] How it works: A professional editor reviews the content.

[0322] Step 29:

[0323] A professional editor will perform a final proofreading if necessary to optimize the document for style and consistency, and then the final file will be uploaded to the server after any corrections have been implemented.

[0324] input:

[0325] Document and layout, cover design

[0326] Action: Final proofreading and corrections.

[0327] output:

[0328] Final File

[0329] Step 30:

[0330] The server compiles the finished files and generates the digital format and print files.

[0331] input:

[0332] Final File

[0333] What it does: Generates digital and print files.

[0334] output:

[0335] Digital and print files

[0336] This allows the entire process from writing to publishing an autobiography to be efficiently automated.

[0337] (Application example 1)

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

[0339] In today's virtual stores, users need to be able to quickly and accurately obtain product information. Conventional systems make it difficult for users to gather information, resulting in a long wait time before obtaining the information they need, or they run the risk of obtaining inaccurate information. Under these circumstances, there is a need to provide accurate product information in real time to improve the user's purchasing experience. Furthermore, it is necessary to ensure a smooth purchasing process by quickly responding to user input and making appropriate suggestions.

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

[0341] In this invention, the server includes a user authentication means, a data collection means for interacting with the generating AI, and a fact-checking means. This allows users to obtain accurate product information in real time. Furthermore, by utilizing the content generation and display means, the shopping experience in the virtual store can be improved, facilitating the user's purchasing process.

[0342] "User authentication means" is a function for identifying and authenticating users who access the system.

[0343] The "data collection means for interacting with the generative artificial intelligence" is a function for collecting input information from the user and interacting with the generative artificial intelligence based on that information.

[0344] "Fact-checking tools" are functions that utilize external and internal databases to verify the accuracy of collected information.

[0345] The "automatic content generation means" is a function that automatically generates content based on collected data.

[0346] The "automatic content proofreading means" is a function that automatically checks and corrects the grammar and style of the generated content.

[0347] The "automatic layout generation means" is a function that automatically formats the appearance and structure of the generated content.

[0348] The "automatic cover design generation means" is a function that automatically creates a cover design based on specified requirements.

[0349] "Final proofreading and correction means" refers to a function that allows professionals to finally proofread and correct the generated content.

[0350] "Digital and print file generator" means a function for generating files in digital or print format for the final content.

[0351] The "content generation and display means" is a function for displaying the generated content on a display device in real time.

[0352] MODE FOR CARRYING OUT THE INVENTION

[0353] Program Overview

[0354] A system based on this application example is implemented using the following hardware and software components:

[0355] Hardware: Smart glasses (e.g. Microsoft HoloLens, Google Glass, etc.)

[0356] Software: Python 3.x, Requests library, SDK for smart glasses

[0357] Program processing explanation

[0358] User Authentication

[0359] The user puts on the smart glasses and starts the application. When the user enters their user ID and password, the device sends the entered authentication information to the server. The server checks the received authentication information against a database for verification. If authentication is successful, the server generates a session ID and notifies the device of successful authentication. If authentication fails, the server returns an error message to the device.

[0360] Data collection

[0361] Once user authentication is complete, the user begins a dialogue with the generation AI through the smart glasses interface. The user's voice input (e.g., "I want the latest red smartphone") is sent in real time by the device to the server. The server passes the dialogue to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated to accumulate the necessary information.

[0362] Fact Check

[0363] The server analyzes the collected data and sends a fact-check request to the generation AI. The generation AI checks the accuracy of the provided information by searching the internet and its internal database. If there is a discrepancy with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-check results and presents the correction suggestion to the user.

[0364] Content generation and real-time display

[0365] The server sends a content generation request to the generation AI based on the collected data and fact-checked data. The generation AI analyzes the data and generates appropriate product information and purchase suggestions. The generated content is sent to the device via the server, and the device displays it in real time on the smart glasses display.

[0366] Examples and prompts

[0367] Examples:

[0368] A user speaks, "I want the latest red smartphone."

[0369] The application responds, "Searching for the latest red smartphone..." and displays related products and pricing information on the smart glasses' display.

[0370] Example prompt sentence:

[0371] User says: "I want the latest red smartphone."

[0372] Prompt sent to the AI: "Search for product information on the latest red smartphone and suggest it to the user."

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

[0374] Step 1:

[0375] The user puts on the smart glasses and starts the application. A user ID and password entry screen appears on the smart glasses display. The user enters the user ID and password. The entered authentication information (user ID and password) is sent from the device to the server. The server compares the received authentication information with the database and generates an authentication result. If successful, it generates a session ID and sends a notification of successful authentication to the device, and if unsuccessful, it sends back an error message. (Input: user ID, password; Output: authentication result, session ID or error message)

[0376] Step 2:

[0377] Once user authentication is complete, the user begins a dialogue with the generated AI through the smart glasses. The user inquires about the system via voice input (e.g., "I want the latest red smartphone"). The voice data is converted into text data by the device and sent to the server. (Input: User voice input, Output: Text data)

[0378] Step 3:

[0379] The server passes the text data to the generation AI, which then generates a prompt that asks related questions and searches for product information. The generation AI then asks the user further questions based on the prompt to gather more detailed information. This interaction is repeated with additional input from the user. (Input: user text data, Output: prompt to the generation AI, next question from the generation AI)

[0380] Step 4:

[0381] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by referencing the internet and internal databases. Once the information has been verified, the fact-check results are returned to the server. (Input: collected data, output: fact-check results)

[0382] Step 5:

[0383] The fact-check results are analyzed, and if there is any contradictory data, the AI ​​generates correction suggestions and returns them to the server. The server then presents the fact-check results and correction suggestions to the user. (Input: Fact-check results, Output: Correction suggestions)

[0384] Step 6:

[0385] The server sends a content generation request to the generation AI based on the fact-checked data. The generation AI analyzes the data and generates content including optimal purchasing suggestions for the user. The generated content is sent to the device via the server, and the device displays it in real time on the smart glasses display. (Input: fact-checked data, Output: generated content)

[0386] Step 7:

[0387] If the user checks the generated content and wishes to proceed with the purchase, they send instructions to the server via their terminal. The server then confirms the purchase procedure, obtains the necessary information, and completes the process. (Input: User's purchase instructions, Output: Notification of purchase process completion)

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

[0389] MODE FOR CARRYING OUT THE INVENTION

[0390] The present invention provides a system including a user authentication means, a data collection means for interacting with a generation artificial intelligence, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, a digital and print file generation means, and an emotion engine for recognizing user emotions.

[0391] User Authentication

[0392] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal sends the entered authentication information to the server. The server queries the database for the received authentication information and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session, but if authentication fails, it returns an error message to the terminal.

[0393] Data collection

[0394] Once authentication is complete, the user begins a dialogue with the generation AI on the interface. The device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time. The server passes the dialogue content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated to accumulate the necessary information. The device also contains an emotion engine that recognizes emotions from the user's facial expressions and tone of voice. This allows the emotion engine to analyze the user's emotional state in real time. The emotion engine's analysis results are sent to the server and are used to adjust the dialogue content.

[0395] Fact Check

[0396] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by consulting the internet and internal databases. For example, if a user states that "a new product was a big hit in 2005," the generation AI checks that information against external sources. If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-check results and presents the correction suggestion to the user.

[0397] Content Generation

[0398] The server sends a request to the generative AI to create a draft structure for the autobiography based on the collected episodes and fact-checked data. The generative AI analyzes the data and determines the chapter structure, order, and placement of key episodes in the autobiography. For example, it generates chapters such as an introduction, career turning points, and a record of successes and failures. It also adjusts the tone and content of the text according to the user's emotional state. For example, if the user is excited, it generates powerful sentences that reflect that emotion. The generative AI returns the first draft to the server, which stores it in a database.

[0399] Proofreading and Layout

[0400] The server requests the generation AI and instructs it to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency and makes any necessary corrections. The generation AI then re-layouts the corrected document. The layout includes header file settings, font selection, and column settings. The server saves the completed document and layout in a database.

[0401] Cover creation

[0402] The user inputs the requirements for the cover design into the interface (e.g., "white text on a blue background"). The device sends the user's requirements to the server. The server requests the generation AI to create multiple cover design proposals. The generation AI generates the design proposals and returns them to the server. The server then presents the generated design proposals to the user. It is also possible to adjust the theme and colors of the cover design proposals based on the user's emotions recognized by the emotion engine. For example, if the user expresses an emotion of joy, a design using bright colors is suggested.

[0403] Final proofreading and polishing

[0404] A professional editor accesses the server using a device to review the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The professional editor incorporates the corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format or a file for printing.

[0405] Publication and Distribution

[0406] The server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server sends a notification of publication completion to the user and the professional editor. If desired, the user has access to a dashboard to monitor the sales status of the published book. The server collects sales data in real time and displays it on the dashboard.

[0407] The above is a detailed description of the embodiment of the present invention. By using this system, a high-quality autobiography that reflects the user's emotions can be created and published quickly and efficiently.

[0408] The processing flow will be explained below.

[0409] Step 1:

[0410] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal then sends the entered authentication information to the server.

[0411] Step 2:

[0412] The server queries the database for the authentication information it receives and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session. If authentication fails, an error message is returned to the terminal.

[0413] Step 3:

[0414] After authentication is complete, the user begins interacting with the generative AI on the interface, and the device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time.

[0415] Step 4:

[0416] The server passes the dialogue to the AI ​​generator, which then generates relevant and probing questions. The AI ​​then generates the next most appropriate question and sends it to the device.

[0417] Step 5:

[0418] The device analyzes the user's facial expressions and tone of voice in real time, and recognizes emotions using an emotion engine to detect emotional states (e.g., joy, sadness, excitement, etc.) and send the results to the server.

[0419] Step 6:

[0420] The user enters answers to questions, which are then sent to the server via the device. This process is repeated to accumulate the necessary information. The server then stores the dialogue log and emotion data in a database.

[0421] Step 7:

[0422] The server analyzes the collected data and sends a fact-check request to the Generator AI, which then checks the internet and its internal databases to verify the accuracy of the information provided.

[0423] Step 8:

[0424] If there is a contradiction with the confirmed data, the generation AI generates a correction suggestion and returns it to the server, which then updates the fact-checking results in the database and presents the correction suggestion to the user.

[0425] Step 9:

[0426] The server sends a request to the AI ​​generator to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The AI ​​generator then determines the chapter structure and order of the autobiography, as well as the placement of key episodes.

[0427] Step 10:

[0428] The AI ​​adjusts the tone and content of the text based on the user's emotional state. For example, if the user is excited, it will generate powerful text that reflects that emotion.

[0429] Step 11:

[0430] The generative AI sends the first draft back to the server, which stores it in a database.

[0431] Step 12:

[0432] The server requests the AI ​​to perform automatic proofreading, which checks grammar, spelling, and style consistency and makes any necessary corrections.

[0433] Step 13:

[0434] The generative AI then re-layouts the revised document, including header file settings, font selection, and column settings. The server then stores the completed document and layout in a database.

[0435] Step 14:

[0436] The user enters the requirements for the cover design into the interface (e.g., "white text on a blue background"), and the device sends the user's requirements to the server.

[0437] Step 15:

[0438] The server requests the AI ​​to create multiple cover design proposals, which the AI ​​then generates and returns to the server.

[0439] Step 16:

[0440] The server presents the generated design proposals to the user. It also adjusts the theme and color of the cover design proposal based on the user's emotions as recognized by the emotion engine. For example, if the user expresses joy, it suggests a design using bright colors.

[0441] Step 17:

[0442] The user selects a design of their choice and transmits the selection result to the server via the terminal.

[0443] Step 18:

[0444] A professional editor accesses the server using a terminal to check the generated document, layout, and cover design. If necessary, the professional editor performs final proofreading to optimize the document's style and consistency.

[0445] Step 19:

[0446] A professional editor will make the necessary edits and upload the final file to a server, which will then compile the finished file and generate a digital or print format.

[0447] Step 20:

[0448] The server uploads the final file to the publishing platform, and the server sends a notification of publication completion to the user and the professional editor.

[0449] Step 21:

[0450] If desired, users can access a dashboard to monitor the sales status of their published books. The server collects sales data in real time and displays it on the dashboard.

[0451] The above is a detailed description of the embodiment of the present invention. By using this system, a high-quality autobiography that reflects the user's emotions can be created and published quickly and efficiently.

[0452] Example 2

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

[0454] Conventional autobiography creation systems have the problem that it is difficult to generate high-quality content that reflects the user's emotions, and there is a lack of automated fact-checking and proofreading, making it difficult to create and publish autobiographies efficiently and accurately.

[0455] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a user authentication means, a data collection means for interacting with the generation AI, and a means for fact-checking the collected data. This makes it possible to efficiently generate high-quality content that reflects the user's emotions and ensure accuracy.

[0456] "User authentication means" refers to a means for verifying the identity of a user when accessing a system.

[0457] The "data collection means for interacting with the generating AI" is a means for collecting input from the user in real time and passing that data to the generating AI.

[0458] "Means for fact-checking collected data" refers to means for consulting the internet and internal databases to verify the accuracy of collected data.

[0459] "Means for automatically generating content" refers to means for automatically constructing and generating content such as an autobiography based on data collected by a generative artificial intelligence.

[0460] An "automated content proofreading solution" is a solution that checks generated content for grammar, spelling, and style consistency and makes any necessary corrections.

[0461] An "automatic layout generation method" is a method that automatically generates an appropriate layout for the composed content, including columns, fonts, header files, etc.

[0462] The "means for automatically generating a cover design" is a means for automatically generating an appropriate cover design based on requirements from a user.

[0463] "Means for final proofreading and correction" refers to a means for finally checking the generated content and design and making any necessary corrections.

[0464] "Means for generating digital and print files" means means for converting the finished content into a file format suitable for digital and print formatting.

[0465] "Means for recognizing a user's emotions in real time and using them to adjust the content of the dialogue and the generated content" refers to means for analyzing emotions from the user's facial expressions and tone of voice, and adjusting the content of the dialogue and the tone of the generated content based on the obtained emotional information.

[0466] The present invention is a system that includes means for user authentication, means for collecting data to interact with a generative artificial intelligence, means for fact-checking the collected data, means for automatically generating content, means for automatically proofreading the content, means for automatically generating layouts, means for automatically generating cover designs, means for final proofreading and corrections, means for generating digital and print files, and means for recognizing user emotions in real time and using them to adjust the content of the interaction and the generated content.

[0467] First, the user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password for user authentication. The terminal sends the entered authentication information to the server, and the server queries the received authentication information against a database for verification. If authentication is successful, the server generates a session ID, and if authentication fails, it returns an error message to the terminal.

[0468] Next, once authentication is complete, the user can begin a dialogue with the generation AI through the interface. The device sends the user's input to the server in real time, and the server passes the dialogue content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated to accumulate the necessary information. The device also contains an emotion engine that recognizes emotions from the user's facial expressions and tone of voice, and sends the emotion engine's analysis results to the server to help adjust the dialogue content.

[0469] For fact-checking, the server analyzes the collected data and sends a fact-check request to the generation AI. The generation AI checks the accuracy of the provided information by referencing the internet and internal databases. For example, it checks the content "A new product was a big hit in 2005." If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server then updates the database with the fact-check results and presents the correction suggestion to the user.

[0470] Next, the server sends a request to the generative AI to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The generative AI analyzes the data, determines the autobiography's chapter structure, order, and placement of key episodes, and adjusts the tone of the writing according to the user's emotional state. The generative AI returns the first draft to the server, which stores it in a database.

[0471] The server then requests the generation AI to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency, makes any necessary corrections, and then re-layouts the text. The server then saves the completed document and layout in a database.

[0472] Next, the user inputs the requirements for the cover design into the interface. For example, "white text on a blue background." The device sends this information to the server, which then requests the generation AI to create the cover design. The generation AI generates multiple design proposals and sends them to the server. The server then presents the generated design proposals to the user and adjusts the design based on the results of the emotion engine.

[0473] Finally, a professional editor accesses the server using a terminal to review the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The professional editor uploads the final file with the edits reflected to the server, which then converts the finished file into a digital format or a file for printing.

[0474] Finally, the server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server then notifies the user and the professional editor that publication is complete. If desired, the user can access a dashboard to monitor the sales status of the published book. The server collects sales data in real time and displays it on the dashboard.

[0475] Prompt Sentence Examples

[0476] "Can you please provide some Python code to authenticate a user using a user ID and password?"

[0477] "Can you provide some Python code to interact with the user to gather specific information?"

[0478] "Can you please give me some Python code to check the accuracy of given information on the internet?"

[0479] "Can you please provide some Python code that will generate a draft of an autobiography based on the collected data?"

[0480] "Can you please provide some Python code to automate proofreading and document layout?"

[0481] "Can you please give me some Python code to generate multiple cover design ideas based on given requirements?"

[0482] "Can you give me some Python code to proofread the document and generate a digital format?"

[0483] "Can you please provide me with the Python code to upload my digital files to a publishing platform? Also, how do I collect sales data and display it on a dashboard?"

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

[0485] Step 1: User authentication

[0486] A user accesses the system from a terminal and enters their user ID and password. The terminal sends the entered authentication information to the server. The server queries the database for the received authentication information and verifies it. If authentication is successful, the server generates a session ID, and if authentication fails, it returns an error message to the terminal.

[0487] Input: User ID, Password

[0488] Output: Session ID (if authentication is successful), Error message (if authentication is unsuccessful)

[0489] Specific behavior:

[0490] 1. The user visits the login page and enters their credentials.

[0491] 2. The device sends the authentication information to the server.

[0492] 3. The server performs a database check and returns the results to the terminal.

[0493] Step 2: Data collection

[0494] The user begins a dialogue with the generation AI. The device sends the user's input in real time to the server. The server passes the dialogue content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters a response, which is again sent to the server via the device. The device contains an emotion engine that recognizes emotions from the user's facial expressions and tone of voice, and sends the analysis results to the server.

[0495] Input: User text input, user facial expressions and tone of voice

[0496] Output: Questions from the generative AI, sentiment analysis results

[0497] Specific behavior:

[0498] 1. User types "We entered new markets in 2005."

[0499] 2. The device sends the input to the server.

[0500] 3. The server passes the dialogue to the generation AI, which generates related questions.

[0501] 4. The generating AI sends the question to the device.

[0502] 5. The emotion engine analyzes the user's emotions and sends the results to the server.

[0503] Step 3: Fact Check

[0504] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by searching the internet and its internal database. If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-checking results and presents the correction suggestion to the user.

[0505] Input: Collected data

[0506] Output: Fact check results, suggested corrections

[0507] Specific behavior:

[0508] 1. The server sends a fact-check request to the generating AI.

[0509] 2. The generating AI searches and checks the internet and internal databases.

[0510] 3. If there are any discrepancies, a correction proposal is created and sent to the server.

[0511] 4. The server presents the user with suggested revisions.

[0512] Step 4: Content Generation

[0513] The server sends a request to the generative AI to create a draft of the autobiography. The generative AI analyzes the data and determines the chapter structure, order, and placement of key episodes. It adjusts the tone of the text according to the user's emotional state. The generative AI returns the first draft to the server, which stores it in a database.

[0514] Input: Collected episodes, fact-checked data

[0515] Output: First draft of autobiography

[0516] Specific behavior:

[0517] 1. The server requests the generation AI to create a composition plan.

[0518] 2. The generative AI analyzes the data and determines the chapter structure and main episodes.

[0519] 3. The generative AI creates a first draft and sends it to the server.

[0520] Step 5: Proofreading and layout

[0521] The server requests the generation AI to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency and makes any necessary corrections. The generation AI then re-layouts the corrected document. The server saves the completed document and layout in a database.

[0522] Input: First draft

[0523] Output: Proofread, revised, and laid-out document

[0524] Specific behavior:

[0525] 1. The server asks the generation AI to proofread the text.

[0526] 2. The generative AI checks grammar and spelling and makes corrections.

[0527] 3. The generative AI reconstructs the revised document layout and sends it to the server.

[0528] Step 6: Create the cover

[0529] The user inputs the requirements for the cover design into the interface. The device sends the requirements to the server. The server requests the generation AI to create multiple cover design proposals. The generation AI generates the design proposals and sends them to the server. The server presents the generated design proposals to the user and adjusts them as needed based on the results of the emotion engine.

[0530] Input: Cover design requirements

[0531] Output: Cover design proposal

[0532] Specific behavior:

[0533] 1. The user enters the cover design requirements: "white text on a blue background."

[0534] 2. The device sends the requirements to the server.

[0535] 3. The server asks the generation AI to create a cover design proposal.

[0536] 4. The generative AI generates multiple design proposals and sends them to the server.

[0537] 5. The server presents design proposals to the user and makes adjustments based on sentiment analysis.

[0538] Step 7: Final proofreading and polishing

[0539] A professional editor accesses the server using a device to review the generated document, layout, and cover design. If necessary, a final proofread is performed to optimize the document's style and consistency. The professional editor incorporates the corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format or a file for printing.

[0540] Input: Generated document, layout, and cover design

[0541] Output: Final revised version, digital format, print file

[0542] Specific behavior:

[0543] 1. A professional editor will review the text, layout, and cover design.

[0544] 2. A professional editor performs a final proofread to optimize style and consistency.

[0545] 3. The professional editor makes the necessary changes and uploads the final file to the server.

[0546] 4. The server generates the digital format and print files.

[0547] Step 8: Publishing and Distribution

[0548] The server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server then sends a notification of publication completion to the user and the professional editor. The user can access a dashboard to monitor the sales status of the published book. The server collects real-time sales data and displays it on the dashboard.

[0549] Input: Final file

[0550] Output: Publication notification, sales data display

[0551] Specific behavior:

[0552] 1. The server uploads the final file to the publishing platform.

[0553] 2. The server sends a publication completion notification to the user and the professional editor.

[0554] 3. Users monitor sales on a dashboard.

[0555] 4. The server collects sales data in real time and displays it on the dashboard.

[0556] (Application example 2)

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

[0558] While there have been systems for efficiently creating autobiographies and personal documents, there has been no system that can consistently generate personalized content that reflects the user's emotional information, fact-check, and automate cover design. Furthermore, there has been a demand for a system that can utilize smart devices and enable users without specialized knowledge to easily create high-quality documents.

[0559] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes a user authentication means, a data collection means for interacting with the generation AI, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, a digital and print file generation means, an emotion engine means for recognizing the user's emotional state, and an application installed on the smart device. This enables the generation and distribution of a high-quality, personalized autobiography that reflects emotional information while the user interacts with it through the smart device.

[0560] "User authentication means" refers to a means of authenticating a user using a user ID and password when the user accesses the system.

[0561] The "data collection means for interacting with the generative artificial intelligence" is a means for collecting user input information in real time and supporting interaction with the generative artificial intelligence.

[0562] "Fact-checking tools" are tools that verify information using the internet and internal databases to confirm the accuracy of collected information.

[0563] The "automatic content generation means" is a means for automatically generating the structure and arrangement of episodes based on collected data.

[0564] An "automated content proofreader" is a means for automatically proofreading generated content for consistency of grammar, spelling, and style.

[0565] The "automatic layout generation means" is a means for automatically setting the layout of a document and generating a format and columns.

[0566] The "automatic cover design generation means" is a means for automatically generating a plurality of cover design proposals based on the user's requirements.

[0567] The "final proofreading and correction means" is a means by which a professional editor makes a final check of the generated content and makes any necessary corrections.

[0568] "Digital and print file generator" means a generator that generates finished content in digital format and print files.

[0569] The "emotion engine means for recognizing the user's emotional state" is a means for analyzing the user's emotions in real time from their facial expressions and tone of voice, and using this information to adjust the content of the dialogue.

[0570] An "application installed on a smart device" is an application that is installed on a device such as a smartphone or tablet and that can be operated intuitively by a user.

[0571] This invention is a system that operates in conjunction with a smart device and is composed of means including user authentication, data collection for interacting with a generation AI, fact checking, automatic content generation, automatic content proofreading, automatic layout generation, automatic cover design generation, final proofreading and correction, digital and print file generation, and an emotion engine.

[0572] The system uses the following specific hardware and software:

[0573] 1. Hardware:

[0574] Smart devices (e.g. smartphones, tablets)

[0575] 2. Software:

[0576] Server: Flask (Python)

[0577] Database: PostgreSQL

[0578] Generative AI model: OpenAI GPT-3

[0579] Emotion engine: Microsoft Azure Emotion API

[0580] When a user accesses the application using a smart device, they first undergo user authentication. If authentication is successful, the user begins a dialogue with the generation AI using a conversational interface. The information the user enters is sent to the server in real time, and the generation AI generates the next appropriate question, and the dialogue continues.

[0581] During this dialogue process, the emotion engine analyzes the user's emotions in real time from their facial expressions and tone of voice, and the analysis results are sent to the server, which then adjusts the content of the dialogue and the tone of the text based on that information.

[0582] The collected data is stored on a server and fact-checked using a generative AI. For example, if a user states, "A new product was a big hit in 2005," the generative AI verifies that information against external sources. After this fact-check, the generative AI automatically generates a draft structure for the autobiography. Based on the collected episodes and the data after the fact-check, it generates a draft structure including the chapter structure and episode placement.

[0583] The generated text is checked for grammar and style using an automatic proofreading means, and the document layout is set using an automatic layout generation means.When the user inputs their cover design requests, the generation AI generates multiple cover design proposals and uses an emotion engine to adjust the design theme and color according to the user's emotions.

[0584] Finally, a professional editor will do the final proofreading and editing, and the finished file will be generated in digital and print formats. This digital file will be uploaded to a publishing platform where users can monitor the sales of the published book.

[0585] As a specific example, when a user inputs an episode about entering a new market, the dialogue content is as follows:

[0586] User input: It was 2005 when we expanded into new markets.

[0587] Prompt for Generative AI: You entered a new market in 2005. What was the biggest challenge?

[0588] In this way, the system reflects the user's feelings and allows the user to easily create and publish a high-quality autobiography.

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

[0590] Step 1: User authentication

[0591] A user accesses an application using a smart device (smartphone or tablet) and enters their user ID and password. This authentication information is sent from the device to the server, which checks it against a database to determine whether the authentication was successful. If authentication is successful, the server generates a session ID and returns it to the device. If authentication is unsuccessful, it returns an error message. The input is the user ID and password, and the output is the session ID or an error message.

[0592] Step 2: Data collection

[0593] After authenticating, the user begins interacting with the generation AI through an interface. The user's input (e.g., "We entered a new market in 2005") is sent in real time from the device to the server. The server passes the input to the generation AI, which then generates the next appropriate question. This question is sent to the device, and the user enters an answer, which is then sent again from the device to the server. This process is repeated, accumulating the necessary data. The input is the user's interaction, and the output is the next question.

[0594] Step 3: Analysis by the Emotion Engine

[0595] The device includes an emotion engine that recognizes emotions from the user's facial expressions and tone of voice. This emotional information is sent to the server in real time and used to adjust the content of the dialogue. For example, if the user is excited, the tone and content of the questions generated are adjusted based on this emotional information. The input is the user's facial expressions and tone of voice, and the output is adjustment of the questions generated.

[0596] Step 4: Fact Check

[0597] The server performs fact-checking to verify the accuracy of the collected data. The generating AI checks the accuracy of the provided information by referencing the internet and internal databases. During this process, information such as "A new product was a big hit in 2005" is verified against external sources. The input is the collected data, and the output is fact-checked data.

[0598] Step 5: Content Generation

[0599] The server sends a request to the generation AI to create a draft structure for the autobiography based on the collected episodes and fact-checked data. The generation AI analyzes the data and determines the structure, order, and placement of key episodes in the autobiography. For example, it generates chapters such as an introduction, career turning points, and a record of successes and failures. The input is fact-checked data, and the output is a draft structure for the autobiography.

[0600] Step 6: Auto-Proofreading and Layout Generation

[0601] The server requests the generation AI to perform automatic proofreading of the created text. The generation AI checks grammar, spelling, and style consistency, and makes any necessary corrections. The generation AI then re-lays out the corrected document, setting up header files, selecting fonts, and setting columns. The input is a draft of the autobiography, and the output is the proofread and laid-out document.

[0602] Step 7: Create a cover design

[0603] The user inputs the cover design requirements (e.g., "white text on a blue background") into the interface, and the device sends the requirements to the server. The server then requests the generation AI to generate multiple cover design proposals. Based on the analysis results of the emotion engine, the design theme and colors are adjusted according to the user's emotions. The input is the cover design requirements and the user's emotional information, and the output is the generated cover design proposals.

[0604] Step 8: Final proofreading and polish

[0605] A professional editor accesses the server using a terminal and checks the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The final corrected file is uploaded to the server. The input is the proofread and layout document, and the output is the final checked and corrected document.

[0606] Step 9: Publishing and Distribution

[0607] The server uploads the final file to a publishing platform, for example to multiple digital publishing platforms simultaneously. The user is notified of successful publication and can access a sales dashboard if desired. The input is the final verified and revised document; the output is a successful publication notification and a sales dashboard.

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

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

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

[0611] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0624] MODE FOR CARRYING OUT THE INVENTION

[0625] The present invention provides a system including a user authentication means, a data collection means for interacting with a generation artificial intelligence, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, and a digital and print file generation means.

[0626] User Authentication

[0627] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal sends the entered authentication information to the server. The server queries the database for the received authentication information and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session, but if authentication fails, it returns an error message to the terminal.

[0628] Data collection

[0629] Once authentication is complete, the user begins interacting with the generation AI on the interface. The device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time. The server passes the interaction content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated until the necessary information is accumulated. The server saves the interaction log in a database.

[0630] Fact Check

[0631] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by consulting the internet and internal databases. For example, if a user states that "a new product was a big hit in 2005," the generation AI checks that information against external sources. If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-check results and presents the correction suggestion to the user.

[0632] Content Generation

[0633] The server sends a request to the generative AI to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The generative AI analyzes the data and determines the autobiography's chapter structure, order, and placement of key episodes. For example, it generates chapters such as an introduction, career turning points, and a record of successes and failures. The generative AI returns the first draft to the server, which stores it in a database.

[0634] Proofreading and Layout

[0635] The server requests the generation AI and instructs it to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency and makes any necessary corrections. The generation AI then re-layouts the corrected document. The layout includes header file settings, font selection, and column settings. The server saves the completed document and layout in a database.

[0636] Cover creation

[0637] The user inputs the requirements for the cover design into the interface (e.g., "white text on a blue background"). The device sends the user's requirements to the server. The server requests the generation AI to create multiple cover design proposals. The generation AI generates the design proposals and returns them to the server. The server presents the generated design proposals to the user. The user selects their preferred design and sends the selection to the server via the device.

[0638] Final proofreading and polishing

[0639] A professional editor accesses the server using a device to review the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The professional editor incorporates the corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format or a file for printing.

[0640] Publication and Distribution

[0641] The server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server sends a notification of publication completion to the user and the professional editor. If desired, the user has access to a dashboard to monitor the sales status of the published book. The server collects sales data in real time and displays it on the dashboard.

[0642] The above is a detailed description of the embodiment of the present invention. By using this system, an autobiography can be created and published quickly and efficiently.

[0643] The processing flow will be explained below.

[0644] Step 1:

[0645] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal then sends the entered authentication information to the server.

[0646] Step 2:

[0647] The server queries the database for the authentication information it receives and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session. If authentication fails, an error message is returned to the terminal.

[0648] Step 3:

[0649] After authentication is complete, the user begins interacting with the generative AI on the interface, and the device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time.

[0650] Step 4:

[0651] The server passes the dialogue to the AI ​​generator, which then generates relevant and probing questions. The AI ​​then generates the next most appropriate question and sends it to the device.

[0652] Step 5:

[0653] The user enters an answer, which is then sent to the server via the terminal. This process is repeated until all necessary information is accumulated. The server then saves the dialogue log in a database.

[0654] Step 6:

[0655] The server analyzes the collected data and sends a fact-check request to the Generator AI, which then checks the internet and its internal databases to verify the accuracy of the information provided.

[0656] Step 7:

[0657] If there is a contradiction with the confirmed data, the generation AI generates a correction suggestion and returns it to the server, which then updates the fact-checking results in the database and presents the correction suggestion to the user.

[0658] Step 8:

[0659] The server sends a request to the AI ​​to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The AI ​​then determines the chapter structure and order, as well as the placement of key episodes, and generates a first draft.

[0660] Step 9:

[0661] The server requests the AI ​​to perform automatic proofreading, which checks grammar, spelling, and style consistency and makes any necessary corrections.

[0662] Step 10:

[0663] The generative AI then re-layouts the revised document, including header file settings, font selection, and column settings. The server then stores the completed document and layout in a database.

[0664] Step 11:

[0665] The user enters the requirements for the cover design into the interface (e.g., "white text on a blue background"), and the device sends the user's requirements to the server.

[0666] Step 12:

[0667] The server requests the AI ​​to create multiple cover design proposals, which the AI ​​then generates and returns to the server.

[0668] Step 13:

[0669] The server presents the generated design proposals to the user, who then selects the design they prefer and sends the selection to the server via their terminal.

[0670] Step 14:

[0671] A professional editor accesses the server using a terminal to check the generated document, layout, and cover design. The professional editor then performs a final proofread to optimize the document's style and consistency.

[0672] Step 15:

[0673] A professional editor will make the necessary edits and upload the final file to a server, which will then compile the finished file and generate a digital or print format.

[0674] Step 16:

[0675] The server uploads the final file to the publishing platform, and the server sends a notification of publication completion to the user and the professional editor.

[0676] Step 17:

[0677] If desired, users can access a dashboard to monitor the sales status of their published books. The server collects sales data in real time and displays it on the dashboard.

[0678] The above are the steps of the specific processing flow of the program.

[0679] Example 1

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

[0681] The traditional autobiography creation process is laborious, time-consuming, and often requires specialized knowledge. As a result, individuals who try to create their own autobiographies face many difficulties. To solve this problem, a system is needed to create and publish autobiographies efficiently and quickly by automating each step, including data collection, fact-checking, content creation, proofreading, layout, cover design, final proofreading, and digital and print file creation.

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

[0683] In this invention, the server includes a user authentication means, a data collection means for interacting with the generation AI, and a fact-checking means for analyzing the collected data and checking the authentication information, thereby enabling efficient user authentication and highly reliable data collection and verification.

[0684] "User authentication means" is a means for verifying that a user is a legitimate user when accessing a system.

[0685] The "data collection means for interacting with the generative artificial intelligence" is a means for collecting necessary information through interaction with the user.

[0686] "Fact-checking measures" are measures used to verify the accuracy and veracity of collected data.

[0687] The "automatic content generation means" is a means for automatically generating content based on collected data.

[0688] An "automated content proofreader" is a tool for checking and correcting the consistency of grammar, spelling, and style of generated content.

[0689] The "automatic layout generation means" is a means for automatically generating a page layout based on the proofread content.

[0690] The "automatic cover design generation means" is a means for automatically generating a cover design based on the user's requirements.

[0691] "Final proofreading and correction means" refers to the means for finally checking and correcting the generated content, layout, and cover design.

[0692] "Digital and print file generation means" means for generating the final completed document or design as a digital file and a print file.

[0693] The present invention is a system including a user authentication means, a data collection means for interacting with a generation artificial intelligence, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, and a digital and print file generation means. By using this system, users can efficiently create and publish their autobiographies.

[0694] User Authentication

[0695] A user accesses the system's web page using their own PC or smartphone. The terminal displays an interface and the user enters their user ID and password. For example, the user ID is "user123" and the password is "password123." The terminal encrypts this authentication information and sends it to the server. The server queries its database for the received authentication information, and if matching information is found, it generates a session ID and notifies the start of the session.

[0696] Data collection

[0697] After authentication is complete, the user moves to the dialogue interface and begins a dialogue with the generation AI. For example, they might enter, "We entered a new market in 2005." The device sends this input in real time to the server, which then passes it on to the generation AI. The generation AI then generates related and probing questions (e.g., "Which markets did you enter?"), which the server receives and sends to the device. By repeating this process, the necessary information is accumulated, and the dialogue log is stored in a database.

[0698] Fact Check

[0699] The server analyzes the collected data and sends a fact-checking request to the generation AI. For example, to check a claim such as "The new product was a big hit in 2005," the generation AI consults the internet and internal databases. It verifies the information against external sources and, if there is a discrepancy, generates a correction suggestion and sends it to the server. For example, a correction suggestion might be "The new product was a big hit in 2006, not 2005." The server updates the database and notifies the user of the correction suggestion.

[0700] Content Generation

[0701] Once the fact-checking is complete, the server sends a request to the generative AI to create a draft of the autobiography structure based on the collected anecdotes and verified data. The generative AI analyzes the data and determines the chapter structure, such as an introduction, career turning points, and a record of successes and failures. For example, the chapters might be "Introduction," "Career Shift," and "Success Stories." The generative AI creates a first draft and sends it to the server, where it is stored in a database.

[0702] Content proofing and layout

[0703] The server requests the generation AI to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency, and makes any necessary corrections. For example, it adds punctuation to change "successfully" to "successfully." The generation AI then lays out the proofread text. The layout includes header settings, font selection, column settings, etc. The server saves the completed document and layout in a database.

[0704] Cover creation

[0705] The user inputs the requirements for the cover design into the interface. For example, they specify "white text on a blue background." The device sends this to the server, which then requests the AI ​​to generate a cover design proposal. The server receives the generated design proposals and presents them to the user. The user then selects their preferred design and sends the results to the server via the device.

[0706] Final proofreading and polishing

[0707] A professional editor accesses the server via a device to review the generated document, layout, and cover design. A final proofreading is performed to optimize the document's style and consistency. The professional editor incorporates any corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format and a file for printing.

[0708] Publication and Distribution

[0709] The server uploads the final file to a publishing platform, such as an online bookstore, and sends a notification of publication completion to the user and the professional editor. Optionally, the user can access a dashboard to monitor sales of the published book. The server collects sales data in real time and displays it on the dashboard.

[0710] Examples of concrete examples and prompts

[0711] Examples:

[0712] User types, "In 2005, we entered a new market."

[0713] The generative AI generates the question, "Which markets have you expanded into?"

[0714] Fact check example: "The new product became a big hit in 2006, not 2005" generates a correction suggestion.

[0715] Cover design requirements: "White text on a blue background."

[0716] Example prompt sentence:

[0717] "Prompt for user ID and password authentication. Example: User ID = 'user123', Password = 'password123'"

[0718] "A prompt that generates an appropriate question based on user input. Example: User input = 'We entered new markets in 2005'"

[0719] "A prompt that fact-checks information stated by the user. Example: User input = 'A new product became a big hit in 2005.'"

[0720] "A prompt that generates cover design ideas based on user requirements. Example: requirement = 'white text on blue background'"

[0721] The above is a detailed description of the embodiment of the present invention. This system allows users to efficiently create and publish their own autobiographies using advanced AI technology.

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

[0723] Step 1:

[0724] A user accesses the system's web page using their own terminal. The interface is displayed and they enter their user ID and password. Input information:

[0725] User ID (e.g., user123)

[0726] Password (e.g. password123)

[0727] What it does: You enter your user ID and password into a form, which starts the authentication process.

[0728] Step 2:

[0729] The terminal encrypts the entered authentication information and sends it to the server.

[0730] input:

[0731] Encrypted user ID and password

[0732] How it works: Authentication information is transmitted using the HTTPS protocol, which ensures a high level of security.

[0733] Step 3:

[0734] The server queries the database for the authentication information it receives and verifies it.

[0735] input:

[0736] Encrypted user ID and password

[0737] What it does: Runs an SQL query against the database to find records that match the input information.

[0738] output:

[0739] Match result (success or failure)

[0740] Step 4:

[0741] If authentication is successful, the server generates a session ID and notifies the terminal of the start of the session. If authentication fails, the server returns an error message to the terminal.

[0742] input:

[0743] Matching results

[0744] Behavior: Generates a session ID (e.g., ABC123) and generates a session start message or an error message.

[0745] output:

[0746] Session ID or error message

[0747] Step 5:

[0748] After authentication is complete, the user accesses the dialogue interface and begins dialogue with the generated AI.

[0749] input:

[0750] Authentication successful (Session ID)

[0751] Action: A dialog interface is displayed allowing the user to enter information.

[0752] Step 6:

[0753] The user inputs information into the dialogue interface, for example, "We entered a new market in 2005," and the device sends the input to the server.

[0754] input:

[0755] User input (e.g., "We expanded into new markets in 2005")

[0756] Operation: Input information is sent to the server in real time.

[0757] Step 7:

[0758] The server passes the user's input to the generation AI, which generates related and probing questions.

[0759] input:

[0760] User Input

[0761] How it works: The generation AI runs a prompt to generate a question.

[0762] output:

[0763] Generated questions (e.g., "Which markets have you expanded into?")

[0764] Step 8:

[0765] The server receives the questions generated by the generation AI and sends them to the device.

[0766] input:

[0767] Generated Questions

[0768] Action: Sends the question to the terminal and displays it to the user.

[0769] output:

[0770] The question shown to the user

[0771] Step 9:

[0772] The user answers the generated question and the terminal sends the answer back to the server.

[0773] input:

[0774] User response (e.g., "We have expanded into the Asian market")

[0775] Action: Sends the user's answer to the server.

[0776] Step 10:

[0777] This process is repeated until all necessary information is accumulated. The server stores all interaction logs in a database.

[0778] input:

[0779] User Answers

[0780] What it does: Saves the interaction log to a database.

[0781] output:

[0782] Interaction logs stored in a database

[0783] Step 11:

[0784] The server analyzes the collected data and sends a fact-checking request to the generating AI.

[0785] input:

[0786] Data collected

[0787] What it does: Runs a prompt that asks the generating AI to fact-check something.

[0788] output:

[0789] Fact-check request

[0790] Step 12:

[0791] The generating AI will check the internet and internal databases to verify the accuracy of the information provided.

[0792] input:

[0793] Fact-checked data

[0794] What it does: Validates data against external sources.

[0795] output:

[0796] Verification result (correct / incorrect)

[0797] Step 13:

[0798] If there is a discrepancy with the verified data, the generation AI generates correction suggestions and sends them to the server.

[0799] input:

[0800] confirmation result

[0801] Behavior: If there are any conflicts, generate correction suggestions.

[0802] output:

[0803] Revision suggestions

[0804] Step 14:

[0805] The server reflects the fact-check results in the database and notifies the user of suggested corrections.

[0806] input:

[0807] Revision suggestions

[0808] Action: Update the database and notify the user.

[0809] output:

[0810] Notification of proposed amendments

[0811] Step 15:

[0812] The server sends a request to the generation AI to create a draft of the autobiography structure based on the collected episodes and fact-checked data.

[0813] input:

[0814] Episodes and fact-checked data

[0815] Behavior: Executes a prompt to ask the generation AI to create a configuration.

[0816] output:

[0817] Request for composition plan

[0818] Step 16:

[0819] A generative AI analyzes the data and determines the autobiography's chapter structure, order, and placement of key episodes.

[0820] input:

[0821] Request for composition plan

[0822] What it does: Analyzes data and generates configuration suggestions.

[0823] output:

[0824] Chapter structure (e.g., "Introduction," "Career Turning Points," "Record of Successes and Failures")

[0825] Step 17:

[0826] The generative AI sends the initial draft to the server, which stores it in a database.

[0827] input:

[0828] first draft

[0829] What it does: Saves the first draft to the database.

[0830] output:

[0831] Saved first draft

[0832] Step 18:

[0833] The server requests the generation AI to automatically proofread the created text.

[0834] input:

[0835] Saved first draft

[0836] Behavior: Executes a prompt to ask the generating AI to perform auto-calibration.

[0837] output:

[0838] Automatic proofreading request

[0839] Step 19:

[0840] Generative AI checks grammar, spelling, and style consistency, and makes any necessary corrections.

[0841] input:

[0842] first draft

[0843] What it does: Checks and corrects grammar and spelling.

[0844] output:

[0845] Corrected text

[0846] Step 20:

[0847] The generation AI will then re-layout the revised text, setting headers, selecting fonts, and setting columns.

[0848] input:

[0849] Corrected text

[0850] Action: Lays out the text.

[0851] output:

[0852] Layout text

[0853] Step 21:

[0854] The server stores the completed document and layout in a database.

[0855] input:

[0856] Layout text

[0857] What it does: Saves documents and layouts to a database.

[0858] output:

[0859] Saved Documents and Layouts

[0860] Step 22:

[0861] The user enters the cover design requirements into the interface, for example, specifying "white text on a blue background."

[0862] input:

[0863] Cover design requirements

[0864] Action: Enter design requirements into the interface.

[0865] output:

[0866] Design Requirements

[0867] Step 23:

[0868] The terminal sends the user's requirements to the server.

[0869] input:

[0870] Design Requirements

[0871] Action: Sends requirements to the server.

[0872] output:

[0873] Submitted requirements

[0874] Step 24:

[0875] The server requests the generation AI to create a cover design proposal.

[0876] input:

[0877] Submitted requirements

[0878] Action: Prompt the generation AI to create a cover design proposal.

[0879] output:

[0880] Request for cover design proposal

[0881] Step 25:

[0882] The generation AI generates multiple cover design ideas and sends them to the server.

[0883] input:

[0884] Request for cover design proposal

[0885] What it does: Generate multiple design ideas.

[0886] output:

[0887] Design proposal

[0888] Step 26:

[0889] The server presents the generated design proposal to the user.

[0890] input:

[0891] Design proposal

[0892] What it does: Displays design suggestions to the user.

[0893] output:

[0894] The proposed design

[0895] Step 27:

[0896] The user selects a design of their choice and transmits the selection result to the server via the terminal.

[0897] input:

[0898] Design selection results

[0899] Action: Sends the selection results to the server.

[0900] output:

[0901] Submitted selection results

[0902] Step 28:

[0903] A professional editor uses a terminal to access the server and check the generated document, layout, and cover design.

[0904] input:

[0905] Generated document, layout and cover design

[0906] How it works: A professional editor reviews the content.

[0907] Step 29:

[0908] A professional editor will perform a final proofreading if necessary to optimize the document for style and consistency, and then the final file will be uploaded to the server after any corrections have been implemented.

[0909] input:

[0910] Document and layout, cover design

[0911] Action: Final proofreading and corrections.

[0912] output:

[0913] Final File

[0914] Step 30:

[0915] The server compiles the finished files and generates the digital format and print files.

[0916] input:

[0917] Final File

[0918] What it does: Generates digital and print files.

[0919] output:

[0920] Digital and print files

[0921] This allows the entire process from writing to publishing an autobiography to be efficiently automated.

[0922] (Application example 1)

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

[0924] In today's virtual stores, users need to be able to quickly and accurately obtain product information. Conventional systems make it difficult for users to gather information, resulting in a long wait time before obtaining the information they need, or they run the risk of obtaining inaccurate information. Under these circumstances, there is a need to provide accurate product information in real time to improve the user's purchasing experience. Furthermore, it is necessary to ensure a smooth purchasing process by quickly responding to user input and making appropriate suggestions.

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

[0926] In this invention, the server includes a user authentication means, a data collection means for interacting with the generating AI, and a fact-checking means. This allows users to obtain accurate product information in real time. Furthermore, by utilizing the content generation and display means, the shopping experience in the virtual store can be improved, facilitating the user's purchasing process.

[0927] "User authentication means" is a function for identifying and authenticating users who access the system.

[0928] The "data collection means for interacting with the generative artificial intelligence" is a function for collecting input information from the user and interacting with the generative artificial intelligence based on that information.

[0929] "Fact-checking tools" are functions that utilize external and internal databases to verify the accuracy of collected information.

[0930] The "automatic content generation means" is a function that automatically generates content based on collected data.

[0931] The "automatic content proofreading means" is a function that automatically checks and corrects the grammar and style of the generated content.

[0932] The "automatic layout generation means" is a function that automatically formats the appearance and structure of the generated content.

[0933] The "automatic cover design generation means" is a function that automatically creates a cover design based on specified requirements.

[0934] "Final proofreading and correction means" refers to a function that allows professionals to finally proofread and correct the generated content.

[0935] "Digital and print file generator" means a function for generating files in digital or print format for the final content.

[0936] The "content generation and display means" is a function for displaying the generated content on a display device in real time.

[0937] MODE FOR CARRYING OUT THE INVENTION

[0938] Program Overview

[0939] A system based on this application example is implemented using the following hardware and software components:

[0940] Hardware: Smart glasses (e.g. Microsoft HoloLens, Google Glass, etc.)

[0941] Software: Python 3.x, Requests library, SDK for smart glasses

[0942] Program processing explanation

[0943] User Authentication

[0944] The user puts on the smart glasses and starts the application. When the user enters their user ID and password, the device sends the entered authentication information to the server. The server checks the received authentication information against a database for verification. If authentication is successful, the server generates a session ID and notifies the device of successful authentication. If authentication fails, the server returns an error message to the device.

[0945] Data collection

[0946] Once user authentication is complete, the user begins a dialogue with the generation AI through the smart glasses interface. The user's voice input (e.g., "I want the latest red smartphone") is sent in real time by the device to the server. The server passes the dialogue to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated to accumulate the necessary information.

[0947] Fact Check

[0948] The server analyzes the collected data and sends a fact-check request to the generation AI. The generation AI checks the accuracy of the provided information by searching the internet and its internal database. If there is a discrepancy with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-check results and presents the correction suggestion to the user.

[0949] Content generation and real-time display

[0950] The server sends a content generation request to the generation AI based on the collected data and fact-checked data. The generation AI analyzes the data and generates appropriate product information and purchase suggestions. The generated content is sent to the device via the server, and the device displays it in real time on the smart glasses display.

[0951] Examples and prompts

[0952] Examples:

[0953] A user speaks, "I want the latest red smartphone."

[0954] The application responds, "Searching for the latest red smartphone..." and displays related products and pricing information on the smart glasses' display.

[0955] Example prompt sentence:

[0956] User says: "I want the latest red smartphone."

[0957] Prompt sent to the AI: "Search for product information on the latest red smartphone and suggest it to the user."

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

[0959] Step 1:

[0960] The user puts on the smart glasses and starts the application. A user ID and password entry screen appears on the smart glasses display. The user enters the user ID and password. The entered authentication information (user ID and password) is sent from the device to the server. The server compares the received authentication information with the database and generates an authentication result. If successful, it generates a session ID and sends a notification of successful authentication to the device, and if unsuccessful, it sends back an error message. (Input: user ID, password; Output: authentication result, session ID or error message)

[0961] Step 2:

[0962] Once user authentication is complete, the user begins a dialogue with the generated AI through the smart glasses. The user inquires about the system via voice input (e.g., "I want the latest red smartphone"). The voice data is converted into text data by the device and sent to the server. (Input: User voice input, Output: Text data)

[0963] Step 3:

[0964] The server passes the text data to the generation AI, which then generates a prompt that asks related questions and searches for product information. The generation AI then asks the user further questions based on the prompt to gather more detailed information. This interaction is repeated with additional input from the user. (Input: user text data, Output: prompt to the generation AI, next question from the generation AI)

[0965] Step 4:

[0966] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by referencing the internet and internal databases. Once the information has been verified, the fact-check results are returned to the server. (Input: collected data, output: fact-check results)

[0967] Step 5:

[0968] The fact-check results are analyzed, and if there is any contradictory data, the AI ​​generates correction suggestions and returns them to the server. The server then presents the fact-check results and correction suggestions to the user. (Input: Fact-check results, Output: Correction suggestions)

[0969] Step 6:

[0970] The server sends a content generation request to the generation AI based on the fact-checked data. The generation AI analyzes the data and generates content including optimal purchasing suggestions for the user. The generated content is sent to the device via the server, and the device displays it in real time on the smart glasses display. (Input: fact-checked data, Output: generated content)

[0971] Step 7:

[0972] If the user checks the generated content and wishes to proceed with the purchase, they send instructions to the server via their terminal. The server then confirms the purchase procedure, obtains the necessary information, and completes the process. (Input: User's purchase instructions, Output: Notification of purchase process completion)

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

[0974] MODE FOR CARRYING OUT THE INVENTION

[0975] The present invention provides a system including a user authentication means, a data collection means for interacting with a generation artificial intelligence, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, a digital and print file generation means, and an emotion engine for recognizing user emotions.

[0976] User Authentication

[0977] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal sends the entered authentication information to the server. The server queries the database for the received authentication information and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session, but if authentication fails, it returns an error message to the terminal.

[0978] Data collection

[0979] Once authentication is complete, the user begins a dialogue with the generation AI on the interface. The device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time. The server passes the dialogue content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated to accumulate the necessary information. The device also contains an emotion engine that recognizes emotions from the user's facial expressions and tone of voice. This allows the emotion engine to analyze the user's emotional state in real time. The emotion engine's analysis results are sent to the server and are used to adjust the dialogue content.

[0980] Fact Check

[0981] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by consulting the internet and internal databases. For example, if a user states that "a new product was a big hit in 2005," the generation AI checks that information against external sources. If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-check results and presents the correction suggestion to the user.

[0982] Content Generation

[0983] The server sends a request to the generative AI to create a draft structure for the autobiography based on the collected episodes and fact-checked data. The generative AI analyzes the data and determines the chapter structure, order, and placement of key episodes in the autobiography. For example, it generates chapters such as an introduction, career turning points, and a record of successes and failures. It also adjusts the tone and content of the text according to the user's emotional state. For example, if the user is excited, it generates powerful sentences that reflect that emotion. The generative AI returns the first draft to the server, which stores it in a database.

[0984] Proofreading and Layout

[0985] The server requests the generation AI and instructs it to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency and makes any necessary corrections. The generation AI then re-layouts the corrected document. The layout includes header file settings, font selection, and column settings. The server saves the completed document and layout in a database.

[0986] Cover creation

[0987] The user inputs the requirements for the cover design into the interface (e.g., "white text on a blue background"). The device sends the user's requirements to the server. The server requests the generation AI to create multiple cover design proposals. The generation AI generates the design proposals and returns them to the server. The server then presents the generated design proposals to the user. It is also possible to adjust the theme and colors of the cover design proposals based on the user's emotions recognized by the emotion engine. For example, if the user expresses an emotion of joy, a design using bright colors is suggested.

[0988] Final proofreading and polishing

[0989] A professional editor accesses the server using a device to review the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The professional editor incorporates the corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format or a file for printing.

[0990] Publication and Distribution

[0991] The server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server sends a notification of publication completion to the user and the professional editor. If desired, the user has access to a dashboard to monitor the sales status of the published book. The server collects sales data in real time and displays it on the dashboard.

[0992] The above is a detailed description of the embodiment of the present invention. By using this system, a high-quality autobiography that reflects the user's emotions can be created and published quickly and efficiently.

[0993] The processing flow will be explained below.

[0994] Step 1:

[0995] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal then sends the entered authentication information to the server.

[0996] Step 2:

[0997] The server queries the database for the authentication information it receives and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session. If authentication fails, an error message is returned to the terminal.

[0998] Step 3:

[0999] After authentication is complete, the user begins interacting with the generative AI on the interface, and the device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time.

[1000] Step 4:

[1001] The server passes the dialogue to the AI ​​generator, which then generates relevant and probing questions. The AI ​​then generates the next most appropriate question and sends it to the device.

[1002] Step 5:

[1003] The device analyzes the user's facial expressions and tone of voice in real time, and recognizes emotions using an emotion engine to detect emotional states (e.g., joy, sadness, excitement, etc.) and send the results to the server.

[1004] Step 6:

[1005] The user enters answers to questions, which are then sent to the server via the device. This process is repeated to accumulate the necessary information. The server then stores the dialogue log and emotion data in a database.

[1006] Step 7:

[1007] The server analyzes the collected data and sends a fact-check request to the Generator AI, which then checks the internet and its internal databases to verify the accuracy of the information provided.

[1008] Step 8:

[1009] If there is a contradiction with the confirmed data, the generation AI generates a correction suggestion and returns it to the server, which then updates the fact-checking results in the database and presents the correction suggestion to the user.

[1010] Step 9:

[1011] The server sends a request to the AI ​​generator to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The AI ​​generator then determines the chapter structure and order of the autobiography, as well as the placement of key episodes.

[1012] Step 10:

[1013] The AI ​​adjusts the tone and content of the text based on the user's emotional state. For example, if the user is excited, it will generate powerful text that reflects that emotion.

[1014] Step 11:

[1015] The generative AI sends the first draft back to the server, which stores it in a database.

[1016] Step 12:

[1017] The server requests the AI ​​to perform automatic proofreading, which checks grammar, spelling, and style consistency and makes any necessary corrections.

[1018] Step 13:

[1019] The generative AI then re-layouts the revised document, including header file settings, font selection, and column settings. The server then stores the completed document and layout in a database.

[1020] Step 14:

[1021] The user enters the requirements for the cover design into the interface (e.g., "white text on a blue background"), and the device sends the user's requirements to the server.

[1022] Step 15:

[1023] The server requests the AI ​​to create multiple cover design proposals, which the AI ​​then generates and returns to the server.

[1024] Step 16:

[1025] The server presents the generated design proposals to the user. It also adjusts the theme and color of the cover design proposal based on the user's emotions as recognized by the emotion engine. For example, if the user expresses joy, it suggests a design using bright colors.

[1026] Step 17:

[1027] The user selects a design of their choice and transmits the selection result to the server via the terminal.

[1028] Step 18:

[1029] A professional editor accesses the server using a terminal to check the generated document, layout, and cover design. If necessary, the professional editor performs final proofreading to optimize the document's style and consistency.

[1030] Step 19:

[1031] A professional editor will make the necessary edits and upload the final file to a server, which will then compile the finished file and generate a digital or print format.

[1032] Step 20:

[1033] The server uploads the final file to the publishing platform, and the server sends a notification of publication completion to the user and the professional editor.

[1034] Step 21:

[1035] If desired, users can access a dashboard to monitor the sales status of their published books. The server collects sales data in real time and displays it on the dashboard.

[1036] The above is a detailed description of the embodiment of the present invention. By using this system, a high-quality autobiography that reflects the user's emotions can be created and published quickly and efficiently.

[1037] Example 2

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

[1039] Conventional autobiography creation systems have the problem that it is difficult to generate high-quality content that reflects the user's emotions, and there is a lack of automated fact-checking and proofreading, making it difficult to create and publish autobiographies efficiently and accurately.

[1040] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a user authentication means, a data collection means for interacting with the generation AI, and a means for fact-checking the collected data. This makes it possible to efficiently generate high-quality content that reflects the user's emotions and ensure accuracy.

[1041] "User authentication means" refers to a means for verifying the identity of a user when accessing a system.

[1042] The "data collection means for interacting with the generating AI" is a means for collecting input from the user in real time and passing that data to the generating AI.

[1043] "Means for fact-checking collected data" refers to means for consulting the internet and internal databases to verify the accuracy of collected data.

[1044] "Means for automatically generating content" refers to means for automatically constructing and generating content such as an autobiography based on data collected by a generative artificial intelligence.

[1045] An "automated content proofreading solution" is a solution that checks generated content for grammar, spelling, and style consistency and makes any necessary corrections.

[1046] An "automatic layout generation method" is a method that automatically generates an appropriate layout for the composed content, including columns, fonts, header files, etc.

[1047] The "means for automatically generating a cover design" is a means for automatically generating an appropriate cover design based on requirements from a user.

[1048] "Means for final proofreading and correction" refers to a means for finally checking the generated content and design and making any necessary corrections.

[1049] "Means for generating digital and print files" means means for converting the finished content into a file format suitable for digital and print formatting.

[1050] "Means for recognizing a user's emotions in real time and using them to adjust the content of the dialogue and the generated content" refers to means for analyzing emotions from the user's facial expressions and tone of voice, and adjusting the content of the dialogue and the tone of the generated content based on the obtained emotional information.

[1051] The present invention is a system that includes means for user authentication, means for collecting data to interact with a generative artificial intelligence, means for fact-checking the collected data, means for automatically generating content, means for automatically proofreading the content, means for automatically generating layouts, means for automatically generating cover designs, means for final proofreading and corrections, means for generating digital and print files, and means for recognizing user emotions in real time and using them to adjust the content of the interaction and the generated content.

[1052] First, the user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password for user authentication. The terminal sends the entered authentication information to the server, and the server queries the received authentication information against a database for verification. If authentication is successful, the server generates a session ID, and if authentication fails, it returns an error message to the terminal.

[1053] Next, once authentication is complete, the user can begin a dialogue with the generation AI through the interface. The device sends the user's input to the server in real time, and the server passes the dialogue content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated to accumulate the necessary information. The device also contains an emotion engine that recognizes emotions from the user's facial expressions and tone of voice, and sends the emotion engine's analysis results to the server to help adjust the dialogue content.

[1054] For fact-checking, the server analyzes the collected data and sends a fact-check request to the generation AI. The generation AI checks the accuracy of the provided information by referencing the internet and internal databases. For example, it checks the content "A new product was a big hit in 2005." If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server then updates the database with the fact-check results and presents the correction suggestion to the user.

[1055] Next, the server sends a request to the generative AI to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The generative AI analyzes the data, determines the autobiography's chapter structure, order, and placement of key episodes, and adjusts the tone of the writing according to the user's emotional state. The generative AI returns the first draft to the server, which stores it in a database.

[1056] The server then requests the generation AI to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency, makes any necessary corrections, and then re-layouts the text. The server then saves the completed document and layout in a database.

[1057] Next, the user inputs the requirements for the cover design into the interface. For example, "white text on a blue background." The device sends this information to the server, which then requests the generation AI to create the cover design. The generation AI generates multiple design proposals and sends them to the server. The server then presents the generated design proposals to the user and adjusts the design based on the results of the emotion engine.

[1058] Finally, a professional editor accesses the server using a terminal to review the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The professional editor uploads the final file with the edits reflected to the server, which then converts the finished file into a digital format or a file for printing.

[1059] Finally, the server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server then notifies the user and the professional editor that publication is complete. If desired, the user can access a dashboard to monitor the sales status of the published book. The server collects sales data in real time and displays it on the dashboard.

[1060] Prompt Sentence Examples

[1061] "Can you please provide some Python code to authenticate a user using a user ID and password?"

[1062] "Can you provide some Python code to interact with the user to gather specific information?"

[1063] "Can you please give me some Python code to check the accuracy of given information on the internet?"

[1064] "Can you please provide some Python code that will generate a draft of an autobiography based on the collected data?"

[1065] "Can you please provide some Python code to automate proofreading and document layout?"

[1066] "Can you please give me some Python code to generate multiple cover design ideas based on given requirements?"

[1067] "Can you give me some Python code to proofread the document and generate a digital format?"

[1068] "Can you please provide me with the Python code to upload my digital files to a publishing platform? Also, how do I collect sales data and display it on a dashboard?"

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

[1070] Step 1: User authentication

[1071] A user accesses the system from a terminal and enters their user ID and password. The terminal sends the entered authentication information to the server. The server queries the database for the received authentication information and verifies it. If authentication is successful, the server generates a session ID, and if authentication fails, it returns an error message to the terminal.

[1072] Input: User ID, Password

[1073] Output: Session ID (if authentication is successful), Error message (if authentication is unsuccessful)

[1074] Specific behavior:

[1075] 1. The user visits the login page and enters their credentials.

[1076] 2. The device sends the authentication information to the server.

[1077] 3. The server performs a database check and returns the results to the terminal.

[1078] Step 2: Data collection

[1079] The user begins a dialogue with the generation AI. The device sends the user's input in real time to the server. The server passes the dialogue content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters a response, which is again sent to the server via the device. The device contains an emotion engine that recognizes emotions from the user's facial expressions and tone of voice, and sends the analysis results to the server.

[1080] Input: User text input, user facial expressions and tone of voice

[1081] Output: Questions from the generative AI, sentiment analysis results

[1082] Specific behavior:

[1083] 1. User types "We entered new markets in 2005."

[1084] 2. The device sends the input to the server.

[1085] 3. The server passes the dialogue to the generation AI, which generates related questions.

[1086] 4. The generating AI sends the question to the device.

[1087] 5. The emotion engine analyzes the user's emotions and sends the results to the server.

[1088] Step 3: Fact Check

[1089] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by searching the internet and its internal database. If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-checking results and presents the correction suggestion to the user.

[1090] Input: Collected data

[1091] Output: Fact check results, suggested corrections

[1092] Specific behavior:

[1093] 1. The server sends a fact-check request to the generating AI.

[1094] 2. The generating AI searches and checks the internet and internal databases.

[1095] 3. If there are any discrepancies, a correction proposal is created and sent to the server.

[1096] 4. The server presents the user with suggested revisions.

[1097] Step 4: Content Generation

[1098] The server sends a request to the generative AI to create a draft of the autobiography. The generative AI analyzes the data and determines the chapter structure, order, and placement of key episodes. It adjusts the tone of the text according to the user's emotional state. The generative AI returns the first draft to the server, which stores it in a database.

[1099] Input: Collected episodes, fact-checked data

[1100] Output: First draft of autobiography

[1101] Specific behavior:

[1102] 1. The server requests the generation AI to create a composition plan.

[1103] 2. The generative AI analyzes the data and determines the chapter structure and main episodes.

[1104] 3. The generative AI creates a first draft and sends it to the server.

[1105] Step 5: Proofreading and layout

[1106] The server requests the generation AI to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency and makes any necessary corrections. The generation AI then re-layouts the corrected document. The server saves the completed document and layout in a database.

[1107] Input: First draft

[1108] Output: Proofread, revised, and laid-out document

[1109] Specific behavior:

[1110] 1. The server asks the generation AI to proofread the text.

[1111] 2. The generative AI checks grammar and spelling and makes corrections.

[1112] 3. The generative AI reconstructs the revised document layout and sends it to the server.

[1113] Step 6: Create the cover

[1114] The user inputs the requirements for the cover design into the interface. The device sends the requirements to the server. The server requests the generation AI to create multiple cover design proposals. The generation AI generates the design proposals and sends them to the server. The server presents the generated design proposals to the user and adjusts them as needed based on the results of the emotion engine.

[1115] Input: Cover design requirements

[1116] Output: Cover design proposal

[1117] Specific behavior:

[1118] 1. The user enters the cover design requirements: "white text on a blue background."

[1119] 2. The device sends the requirements to the server.

[1120] 3. The server asks the generation AI to create a cover design proposal.

[1121] 4. The generative AI generates multiple design proposals and sends them to the server.

[1122] 5. The server presents design proposals to the user and makes adjustments based on sentiment analysis.

[1123] Step 7: Final proofreading and polishing

[1124] A professional editor accesses the server using a device to review the generated document, layout, and cover design. If necessary, a final proofread is performed to optimize the document's style and consistency. The professional editor incorporates the corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format or a file for printing.

[1125] Input: Generated document, layout, and cover design

[1126] Output: Final revised version, digital format, print file

[1127] Specific behavior:

[1128] 1. A professional editor will review the text, layout, and cover design.

[1129] 2. A professional editor performs a final proofread to optimize style and consistency.

[1130] 3. The professional editor makes the necessary changes and uploads the final file to the server.

[1131] 4. The server generates the digital format and print files.

[1132] Step 8: Publishing and Distribution

[1133] The server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server then sends a notification of publication completion to the user and the professional editor. The user can access a dashboard to monitor the sales status of the published book. The server collects real-time sales data and displays it on the dashboard.

[1134] Input: Final file

[1135] Output: Publication notification, sales data display

[1136] Specific behavior:

[1137] 1. The server uploads the final file to the publishing platform.

[1138] 2. The server sends a publication completion notification to the user and the professional editor.

[1139] 3. Users monitor sales on a dashboard.

[1140] 4. The server collects sales data in real time and displays it on the dashboard.

[1141] (Application example 2)

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

[1143] While there have been systems for efficiently creating autobiographies and personal documents, there has been no system that can consistently generate personalized content that reflects the user's emotional information, fact-check, and automate cover design. Furthermore, there has been a demand for a system that can utilize smart devices and enable users without specialized knowledge to easily create high-quality documents.

[1144] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes a user authentication means, a data collection means for interacting with the generation AI, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, a digital and print file generation means, an emotion engine means for recognizing the user's emotional state, and an application installed on the smart device. This enables the generation and distribution of a high-quality, personalized autobiography that reflects emotional information while the user interacts with it through the smart device.

[1145] "User authentication means" refers to a means of authenticating a user using a user ID and password when the user accesses the system.

[1146] The "data collection means for interacting with the generative artificial intelligence" is a means for collecting user input information in real time and supporting interaction with the generative artificial intelligence.

[1147] "Fact-checking tools" are tools that verify information using the internet and internal databases to confirm the accuracy of collected information.

[1148] The "automatic content generation means" is a means for automatically generating the structure and arrangement of episodes based on collected data.

[1149] An "automated content proofreader" is a means for automatically proofreading generated content for consistency of grammar, spelling, and style.

[1150] The "automatic layout generation means" is a means for automatically setting the layout of a document and generating a format and columns.

[1151] The "automatic cover design generation means" is a means for automatically generating a plurality of cover design proposals based on the user's requirements.

[1152] The "final proofreading and correction means" is a means by which a professional editor makes a final check of the generated content and makes any necessary corrections.

[1153] "Digital and print file generator" means a generator that generates finished content in digital format and print files.

[1154] The "emotion engine means for recognizing the user's emotional state" is a means for analyzing the user's emotions in real time from their facial expressions and tone of voice, and using this information to adjust the content of the dialogue.

[1155] An "application installed on a smart device" is an application that is installed on a device such as a smartphone or tablet and that can be operated intuitively by a user.

[1156] This invention is a system that operates in conjunction with a smart device and is composed of means including user authentication, data collection for interacting with a generation AI, fact checking, automatic content generation, automatic content proofreading, automatic layout generation, automatic cover design generation, final proofreading and correction, digital and print file generation, and an emotion engine.

[1157] The system uses the following specific hardware and software:

[1158] 1. Hardware:

[1159] Smart devices (e.g. smartphones, tablets)

[1160] 2. Software:

[1161] Server: Flask (Python)

[1162] Database: PostgreSQL

[1163] Generative AI model: OpenAI GPT-3

[1164] Emotion engine: Microsoft Azure Emotion API

[1165] When a user accesses the application using a smart device, they first undergo user authentication. If authentication is successful, the user begins a dialogue with the generation AI using a conversational interface. The information the user enters is sent to the server in real time, and the generation AI generates the next appropriate question, and the dialogue continues.

[1166] During this dialogue process, the emotion engine analyzes the user's emotions in real time from their facial expressions and tone of voice, and the analysis results are sent to the server, which then adjusts the content of the dialogue and the tone of the text based on that information.

[1167] The collected data is stored on a server and fact-checked using a generative AI. For example, if a user states, "A new product was a big hit in 2005," the generative AI verifies that information against external sources. After this fact-check, the generative AI automatically generates a draft structure for the autobiography. Based on the collected episodes and the data after the fact-check, it generates a draft structure including the chapter structure and episode placement.

[1168] The generated text is checked for grammar and style using an automatic proofreading means, and the document layout is set using an automatic layout generation means.When the user inputs their cover design requests, the generation AI generates multiple cover design proposals and uses an emotion engine to adjust the design theme and color according to the user's emotions.

[1169] Finally, a professional editor will do the final proofreading and editing, and the finished file will be generated in digital and print formats. This digital file will be uploaded to a publishing platform where users can monitor the sales of the published book.

[1170] As a specific example, when a user inputs an episode about entering a new market, the dialogue content is as follows:

[1171] User input: It was 2005 when we expanded into new markets.

[1172] Prompt for Generative AI: You entered a new market in 2005. What was the biggest challenge?

[1173] In this way, the system reflects the user's feelings and allows the user to easily create and publish a high-quality autobiography.

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

[1175] Step 1: User authentication

[1176] A user accesses an application using a smart device (smartphone or tablet) and enters their user ID and password. This authentication information is sent from the device to the server, which checks it against a database to determine whether the authentication was successful. If authentication is successful, the server generates a session ID and returns it to the device. If authentication is unsuccessful, it returns an error message. The input is the user ID and password, and the output is the session ID or an error message.

[1177] Step 2: Data collection

[1178] After authenticating, the user begins interacting with the generation AI through an interface. The user's input (e.g., "We entered a new market in 2005") is sent in real time from the device to the server. The server passes the input to the generation AI, which then generates the next appropriate question. This question is sent to the device, and the user enters an answer, which is then sent again from the device to the server. This process is repeated, accumulating the necessary data. The input is the user's interaction, and the output is the next question.

[1179] Step 3: Analysis by the Emotion Engine

[1180] The device includes an emotion engine that recognizes emotions from the user's facial expressions and tone of voice. This emotional information is sent to the server in real time and used to adjust the content of the dialogue. For example, if the user is excited, the tone and content of the questions generated are adjusted based on this emotional information. The input is the user's facial expressions and tone of voice, and the output is adjustment of the questions generated.

[1181] Step 4: Fact Check

[1182] The server performs fact-checking to verify the accuracy of the collected data. The generating AI checks the accuracy of the provided information by referencing the internet and internal databases. During this process, information such as "A new product was a big hit in 2005" is verified against external sources. The input is the collected data, and the output is fact-checked data.

[1183] Step 5: Content Generation

[1184] The server sends a request to the generation AI to create a draft structure for the autobiography based on the collected episodes and fact-checked data. The generation AI analyzes the data and determines the structure, order, and placement of key episodes in the autobiography. For example, it generates chapters such as an introduction, career turning points, and a record of successes and failures. The input is fact-checked data, and the output is a draft structure for the autobiography.

[1185] Step 6: Auto-Proofreading and Layout Generation

[1186] The server requests the generation AI to perform automatic proofreading of the created text. The generation AI checks grammar, spelling, and style consistency, and makes any necessary corrections. The generation AI then re-lays out the corrected document, setting up header files, selecting fonts, and setting columns. The input is a draft of the autobiography, and the output is the proofread and laid-out document.

[1187] Step 7: Create a cover design

[1188] The user inputs the cover design requirements (e.g., "white text on a blue background") into the interface, and the device sends the requirements to the server. The server then requests the generation AI to generate multiple cover design proposals. Based on the analysis results of the emotion engine, the design theme and colors are adjusted according to the user's emotions. The input is the cover design requirements and the user's emotional information, and the output is the generated cover design proposals.

[1189] Step 8: Final proofreading and polish

[1190] A professional editor accesses the server using a terminal and checks the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The final corrected file is uploaded to the server. The input is the proofread and layout document, and the output is the final checked and corrected document.

[1191] Step 9: Publishing and Distribution

[1192] The server uploads the final file to a publishing platform, for example to multiple digital publishing platforms simultaneously. The user is notified of successful publication and can access a sales dashboard if desired. The input is the final verified and revised document; the output is a successful publication notification and a sales dashboard.

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

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

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

[1196] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1209] MODE FOR CARRYING OUT THE INVENTION

[1210] The present invention provides a system including a user authentication means, a data collection means for interacting with a generation artificial intelligence, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, and a digital and print file generation means.

[1211] User Authentication

[1212] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal sends the entered authentication information to the server. The server queries the database for the received authentication information and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session, but if authentication fails, it returns an error message to the terminal.

[1213] Data collection

[1214] Once authentication is complete, the user begins interacting with the generation AI on the interface. The device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time. The server passes the interaction content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated until the necessary information is accumulated. The server saves the interaction log in a database.

[1215] Fact Check

[1216] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by consulting the internet and internal databases. For example, if a user states that "a new product was a big hit in 2005," the generation AI checks that information against external sources. If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-check results and presents the correction suggestion to the user.

[1217] Content Generation

[1218] The server sends a request to the generative AI to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The generative AI analyzes the data and determines the autobiography's chapter structure, order, and placement of key episodes. For example, it generates chapters such as an introduction, career turning points, and a record of successes and failures. The generative AI returns the first draft to the server, which stores it in a database.

[1219] Proofreading and Layout

[1220] The server requests the generation AI and instructs it to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency and makes any necessary corrections. The generation AI then re-layouts the corrected document. The layout includes header file settings, font selection, and column settings. The server saves the completed document and layout in a database.

[1221] Cover creation

[1222] The user inputs the requirements for the cover design into the interface (e.g., "white text on a blue background"). The device sends the user's requirements to the server. The server requests the generation AI to create multiple cover design proposals. The generation AI generates the design proposals and returns them to the server. The server presents the generated design proposals to the user. The user selects their preferred design and sends the selection to the server via the device.

[1223] Final proofreading and polishing

[1224] A professional editor accesses the server using a device to review the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The professional editor incorporates the corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format or a file for printing.

[1225] Publication and Distribution

[1226] The server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server sends a notification of publication completion to the user and the professional editor. If desired, the user has access to a dashboard to monitor the sales status of the published book. The server collects sales data in real time and displays it on the dashboard.

[1227] The above is a detailed description of the embodiment of the present invention. By using this system, an autobiography can be created and published quickly and efficiently.

[1228] The processing flow will be explained below.

[1229] Step 1:

[1230] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal then sends the entered authentication information to the server.

[1231] Step 2:

[1232] The server queries the database for the authentication information it receives and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session. If authentication fails, an error message is returned to the terminal.

[1233] Step 3:

[1234] After authentication is complete, the user begins interacting with the generative AI on the interface, and the device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time.

[1235] Step 4:

[1236] The server passes the dialogue to the AI ​​generator, which then generates relevant and probing questions. The AI ​​then generates the next most appropriate question and sends it to the device.

[1237] Step 5:

[1238] The user enters an answer, which is then sent to the server via the terminal. This process is repeated until all necessary information is accumulated. The server then saves the dialogue log in a database.

[1239] Step 6:

[1240] The server analyzes the collected data and sends a fact-check request to the Generator AI, which then checks the internet and its internal databases to verify the accuracy of the information provided.

[1241] Step 7:

[1242] If there is a contradiction with the confirmed data, the generation AI generates a correction suggestion and returns it to the server, which then updates the fact-checking results in the database and presents the correction suggestion to the user.

[1243] Step 8:

[1244] The server sends a request to the AI ​​to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The AI ​​then determines the chapter structure and order, as well as the placement of key episodes, and generates a first draft.

[1245] Step 9:

[1246] The server requests the AI ​​to perform automatic proofreading, which checks grammar, spelling, and style consistency and makes any necessary corrections.

[1247] Step 10:

[1248] The generative AI then re-layouts the revised document, including header file settings, font selection, and column settings. The server then stores the completed document and layout in a database.

[1249] Step 11:

[1250] The user enters the requirements for the cover design into the interface (e.g., "white text on a blue background"), and the device sends the user's requirements to the server.

[1251] Step 12:

[1252] The server requests the AI ​​to create multiple cover design proposals, which the AI ​​then generates and returns to the server.

[1253] Step 13:

[1254] The server presents the generated design proposals to the user, who then selects the design they prefer and sends the selection to the server via their terminal.

[1255] Step 14:

[1256] A professional editor accesses the server using a terminal to check the generated document, layout, and cover design. The professional editor then performs a final proofread to optimize the document's style and consistency.

[1257] Step 15:

[1258] A professional editor will make the necessary edits and upload the final file to a server, which will then compile the finished file and generate a digital or print format.

[1259] Step 16:

[1260] The server uploads the final file to the publishing platform, and the server sends a notification of publication completion to the user and the professional editor.

[1261] Step 17:

[1262] If desired, users can access a dashboard to monitor the sales status of their published books. The server collects sales data in real time and displays it on the dashboard.

[1263] The above are the steps of the specific processing flow of the program.

[1264] Example 1

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

[1266] The traditional autobiography creation process is laborious, time-consuming, and often requires specialized knowledge. As a result, individuals who try to create their own autobiographies face many difficulties. To solve this problem, a system is needed to create and publish autobiographies efficiently and quickly by automating each step, including data collection, fact-checking, content creation, proofreading, layout, cover design, final proofreading, and digital and print file creation.

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

[1268] In this invention, the server includes a user authentication means, a data collection means for interacting with the generation AI, and a fact-checking means for analyzing the collected data and checking the authentication information, thereby enabling efficient user authentication and highly reliable data collection and verification.

[1269] "User authentication means" is a means for verifying that a user is a legitimate user when accessing a system.

[1270] The "data collection means for interacting with the generative artificial intelligence" is a means for collecting necessary information through interaction with the user.

[1271] "Fact-checking measures" are measures used to verify the accuracy and veracity of collected data.

[1272] The "automatic content generation means" is a means for automatically generating content based on collected data.

[1273] An "automated content proofreader" is a tool for checking and correcting the consistency of grammar, spelling, and style of generated content.

[1274] The "automatic layout generation means" is a means for automatically generating a page layout based on the proofread content.

[1275] The "automatic cover design generation means" is a means for automatically generating a cover design based on the user's requirements.

[1276] "Final proofreading and correction means" refers to the means for finally checking and correcting the generated content, layout, and cover design.

[1277] "Digital and print file generation means" means for generating the final completed document or design as a digital file and a print file.

[1278] The present invention is a system including a user authentication means, a data collection means for interacting with a generation artificial intelligence, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, and a digital and print file generation means. By using this system, users can efficiently create and publish their autobiographies.

[1279] User Authentication

[1280] A user accesses the system's web page using their own PC or smartphone. The terminal displays an interface and the user enters their user ID and password. For example, the user ID is "user123" and the password is "password123." The terminal encrypts this authentication information and sends it to the server. The server queries its database for the received authentication information, and if matching information is found, it generates a session ID and notifies the start of the session.

[1281] Data collection

[1282] After authentication is complete, the user moves to the dialogue interface and begins a dialogue with the generation AI. For example, they might enter, "We entered a new market in 2005." The device sends this input in real time to the server, which then passes it on to the generation AI. The generation AI then generates related and probing questions (e.g., "Which markets did you enter?"), which the server receives and sends to the device. By repeating this process, the necessary information is accumulated, and the dialogue log is stored in a database.

[1283] Fact Check

[1284] The server analyzes the collected data and sends a fact-checking request to the generation AI. For example, to check a claim such as "The new product was a big hit in 2005," the generation AI consults the internet and internal databases. It verifies the information against external sources and, if there is a discrepancy, generates a correction suggestion and sends it to the server. For example, a correction suggestion might be "The new product was a big hit in 2006, not 2005." The server updates the database and notifies the user of the correction suggestion.

[1285] Content Generation

[1286] Once the fact-checking is complete, the server sends a request to the generative AI to create a draft of the autobiography structure based on the collected anecdotes and verified data. The generative AI analyzes the data and determines the chapter structure, such as an introduction, career turning points, and a record of successes and failures. For example, the chapters might be "Introduction," "Career Shift," and "Success Stories." The generative AI creates a first draft and sends it to the server, where it is stored in a database.

[1287] Content proofing and layout

[1288] The server requests the generation AI to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency, and makes any necessary corrections. For example, it adds punctuation to change "successfully" to "successfully." The generation AI then lays out the proofread text. The layout includes header settings, font selection, column settings, etc. The server saves the completed document and layout in a database.

[1289] Cover creation

[1290] The user inputs the requirements for the cover design into the interface. For example, they specify "white text on a blue background." The device sends this to the server, which then requests the AI ​​to generate a cover design proposal. The server receives the generated design proposals and presents them to the user. The user then selects their preferred design and sends the results to the server via the device.

[1291] Final proofreading and polishing

[1292] A professional editor accesses the server via a device to review the generated document, layout, and cover design. A final proofreading is performed to optimize the document's style and consistency. The professional editor incorporates any corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format and a file for printing.

[1293] Publication and Distribution

[1294] The server uploads the final file to a publishing platform, such as an online bookstore, and sends a notification of publication completion to the user and the professional editor. Optionally, the user can access a dashboard to monitor sales of the published book. The server collects sales data in real time and displays it on the dashboard.

[1295] Examples of concrete examples and prompts

[1296] Examples:

[1297] User types, "In 2005, we entered a new market."

[1298] The generative AI generates the question, "Which markets have you expanded into?"

[1299] Fact check example: "The new product became a big hit in 2006, not 2005" generates a correction suggestion.

[1300] Cover design requirements: "White text on a blue background."

[1301] Example prompt sentence:

[1302] "Prompt for user ID and password authentication. Example: User ID = 'user123', Password = 'password123'"

[1303] "A prompt that generates an appropriate question based on user input. Example: User input = 'We entered new markets in 2005'"

[1304] "A prompt that fact-checks information stated by the user. Example: User input = 'A new product became a big hit in 2005.'"

[1305] "A prompt that generates cover design ideas based on user requirements. Example: requirement = 'white text on blue background'"

[1306] The above is a detailed description of the embodiment of the present invention. This system allows users to efficiently create and publish their own autobiographies using advanced AI technology.

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

[1308] Step 1:

[1309] A user accesses the system's web page using their own terminal. The interface is displayed and they enter their user ID and password. Input information:

[1310] User ID (e.g., user123)

[1311] Password (e.g. password123)

[1312] What it does: You enter your user ID and password into a form, which starts the authentication process.

[1313] Step 2:

[1314] The terminal encrypts the entered authentication information and sends it to the server.

[1315] input:

[1316] Encrypted user ID and password

[1317] How it works: Authentication information is transmitted using the HTTPS protocol, which ensures a high level of security.

[1318] Step 3:

[1319] The server queries the database for the authentication information it receives and verifies it.

[1320] input:

[1321] Encrypted user ID and password

[1322] What it does: Runs an SQL query against the database to find records that match the input information.

[1323] output:

[1324] Match result (success or failure)

[1325] Step 4:

[1326] If authentication is successful, the server generates a session ID and notifies the terminal of the start of the session. If authentication fails, the server returns an error message to the terminal.

[1327] input:

[1328] Matching results

[1329] Behavior: Generates a session ID (e.g., ABC123) and generates a session start message or an error message.

[1330] output:

[1331] Session ID or error message

[1332] Step 5:

[1333] After authentication is complete, the user accesses the dialogue interface and begins dialogue with the generated AI.

[1334] input:

[1335] Authentication successful (Session ID)

[1336] Action: A dialog interface is displayed allowing the user to enter information.

[1337] Step 6:

[1338] The user inputs information into the dialogue interface, for example, "We entered a new market in 2005," and the device sends the input to the server.

[1339] input:

[1340] User input (e.g., "We expanded into new markets in 2005")

[1341] Operation: Input information is sent to the server in real time.

[1342] Step 7:

[1343] The server passes the user's input to the generation AI, which generates related and probing questions.

[1344] input:

[1345] User Input

[1346] How it works: The generation AI runs a prompt to generate a question.

[1347] output:

[1348] Generated questions (e.g., "Which markets have you expanded into?")

[1349] Step 8:

[1350] The server receives the questions generated by the generation AI and sends them to the device.

[1351] input:

[1352] Generated Questions

[1353] Action: Sends the question to the terminal and displays it to the user.

[1354] output:

[1355] The question shown to the user

[1356] Step 9:

[1357] The user answers the generated question and the terminal sends the answer back to the server.

[1358] input:

[1359] User response (e.g., "We have expanded into the Asian market")

[1360] Action: Sends the user's answer to the server.

[1361] Step 10:

[1362] This process is repeated until all necessary information is accumulated. The server stores all interaction logs in a database.

[1363] input:

[1364] User Answers

[1365] What it does: Saves the interaction log to a database.

[1366] output:

[1367] Interaction logs stored in a database

[1368] Step 11:

[1369] The server analyzes the collected data and sends a fact-checking request to the generating AI.

[1370] input:

[1371] Data collected

[1372] What it does: Runs a prompt that asks the generating AI to fact-check something.

[1373] output:

[1374] Fact-check request

[1375] Step 12:

[1376] The generating AI will check the internet and internal databases to verify the accuracy of the information provided.

[1377] input:

[1378] Fact-checked data

[1379] What it does: Validates data against external sources.

[1380] output:

[1381] Verification result (correct / incorrect)

[1382] Step 13:

[1383] If there is a discrepancy with the verified data, the generation AI generates correction suggestions and sends them to the server.

[1384] input:

[1385] confirmation result

[1386] Behavior: If there are any conflicts, generate correction suggestions.

[1387] output:

[1388] Revision suggestions

[1389] Step 14:

[1390] The server reflects the fact-check results in the database and notifies the user of suggested corrections.

[1391] input:

[1392] Revision suggestions

[1393] Action: Update the database and notify the user.

[1394] output:

[1395] Notification of proposed amendments

[1396] Step 15:

[1397] The server sends a request to the generation AI to create a draft of the autobiography structure based on the collected episodes and fact-checked data.

[1398] input:

[1399] Episodes and fact-checked data

[1400] Behavior: Executes a prompt to ask the generation AI to create a configuration.

[1401] output:

[1402] Request for composition plan

[1403] Step 16:

[1404] A generative AI analyzes the data and determines the autobiography's chapter structure, order, and placement of key episodes.

[1405] input:

[1406] Request for composition plan

[1407] What it does: Analyzes data and generates configuration suggestions.

[1408] output:

[1409] Chapter structure (e.g., "Introduction," "Career Turning Points," "Record of Successes and Failures")

[1410] Step 17:

[1411] The generative AI sends the initial draft to the server, which stores it in a database.

[1412] input:

[1413] first draft

[1414] What it does: Saves the first draft to the database.

[1415] output:

[1416] Saved first draft

[1417] Step 18:

[1418] The server requests the generation AI to automatically proofread the created text.

[1419] input:

[1420] Saved first draft

[1421] Behavior: Executes a prompt to ask the generating AI to perform auto-calibration.

[1422] output:

[1423] Automatic proofreading request

[1424] Step 19:

[1425] Generative AI checks grammar, spelling, and style consistency, and makes any necessary corrections.

[1426] input:

[1427] first draft

[1428] What it does: Checks and corrects grammar and spelling.

[1429] output:

[1430] Corrected text

[1431] Step 20:

[1432] The generation AI will then re-layout the revised text, setting headers, selecting fonts, and setting columns.

[1433] input:

[1434] Corrected text

[1435] Action: Lays out the text.

[1436] output:

[1437] Layout text

[1438] Step 21:

[1439] The server stores the completed document and layout in a database.

[1440] input:

[1441] Layout text

[1442] What it does: Saves documents and layouts to a database.

[1443] output:

[1444] Saved Documents and Layouts

[1445] Step 22:

[1446] The user enters the cover design requirements into the interface, for example, specifying "white text on a blue background."

[1447] input:

[1448] Cover design requirements

[1449] Action: Enter design requirements into the interface.

[1450] output:

[1451] Design Requirements

[1452] Step 23:

[1453] The terminal sends the user's requirements to the server.

[1454] input:

[1455] Design Requirements

[1456] Action: Sends requirements to the server.

[1457] output:

[1458] Submitted requirements

[1459] Step 24:

[1460] The server requests the generation AI to create a cover design proposal.

[1461] input:

[1462] Submitted requirements

[1463] Action: Prompt the generation AI to create a cover design proposal.

[1464] output:

[1465] Request for cover design proposal

[1466] Step 25:

[1467] The generation AI generates multiple cover design ideas and sends them to the server.

[1468] input:

[1469] Request for cover design proposal

[1470] What it does: Generate multiple design ideas.

[1471] output:

[1472] Design proposal

[1473] Step 26:

[1474] The server presents the generated design proposal to the user.

[1475] input:

[1476] Design proposal

[1477] What it does: Displays design suggestions to the user.

[1478] output:

[1479] The proposed design

[1480] Step 27:

[1481] The user selects a design of their choice and transmits the selection result to the server via the terminal.

[1482] input:

[1483] Design selection results

[1484] Action: Sends the selection results to the server.

[1485] output:

[1486] Submitted selection results

[1487] Step 28:

[1488] A professional editor uses a terminal to access the server and check the generated document, layout, and cover design.

[1489] input:

[1490] Generated document, layout and cover design

[1491] How it works: A professional editor reviews the content.

[1492] Step 29:

[1493] A professional editor will perform a final proofreading if necessary to optimize the document for style and consistency, and then the final file will be uploaded to the server after any corrections have been implemented.

[1494] input:

[1495] Document and layout, cover design

[1496] Action: Final proofreading and corrections.

[1497] output:

[1498] Final File

[1499] Step 30:

[1500] The server compiles the finished files and generates the digital format and print files.

[1501] input:

[1502] Final File

[1503] What it does: Generates digital and print files.

[1504] output:

[1505] Digital and print files

[1506] This allows the entire process from writing to publishing an autobiography to be efficiently automated.

[1507] (Application example 1)

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

[1509] In today's virtual stores, users need to be able to quickly and accurately obtain product information. Conventional systems make it difficult for users to gather information, resulting in a long wait time before obtaining the information they need, or they run the risk of obtaining inaccurate information. Under these circumstances, there is a need to provide accurate product information in real time to improve the user's purchasing experience. Furthermore, it is necessary to ensure a smooth purchasing process by quickly responding to user input and making appropriate suggestions.

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

[1511] In this invention, the server includes a user authentication means, a data collection means for interacting with the generating AI, and a fact-checking means. This allows users to obtain accurate product information in real time. Furthermore, by utilizing the content generation and display means, the shopping experience in the virtual store can be improved, facilitating the user's purchasing process.

[1512] "User authentication means" is a function for identifying and authenticating users who access the system.

[1513] The "data collection means for interacting with the generative artificial intelligence" is a function for collecting input information from the user and interacting with the generative artificial intelligence based on that information.

[1514] "Fact-checking tools" are functions that utilize external and internal databases to verify the accuracy of collected information.

[1515] The "automatic content generation means" is a function that automatically generates content based on collected data.

[1516] The "automatic content proofreading means" is a function that automatically checks and corrects the grammar and style of the generated content.

[1517] The "automatic layout generation means" is a function that automatically formats the appearance and structure of the generated content.

[1518] The "automatic cover design generation means" is a function that automatically creates a cover design based on specified requirements.

[1519] "Final proofreading and correction means" refers to a function that allows professionals to finally proofread and correct the generated content.

[1520] "Digital and print file generator" means a function for generating files in digital or print format for the final content.

[1521] The "content generation and display means" is a function for displaying the generated content on a display device in real time.

[1522] MODE FOR CARRYING OUT THE INVENTION

[1523] Program Overview

[1524] A system based on this application example is implemented using the following hardware and software components:

[1525] Hardware: Smart glasses (e.g. Microsoft HoloLens, Google Glass, etc.)

[1526] Software: Python 3.x, Requests library, SDK for smart glasses

[1527] Program processing explanation

[1528] User Authentication

[1529] The user puts on the smart glasses and starts the application. When the user enters their user ID and password, the device sends the entered authentication information to the server. The server checks the received authentication information against a database for verification. If authentication is successful, the server generates a session ID and notifies the device of successful authentication. If authentication fails, the server returns an error message to the device.

[1530] Data collection

[1531] Once user authentication is complete, the user begins a dialogue with the generation AI through the smart glasses interface. The user's voice input (e.g., "I want the latest red smartphone") is sent in real time by the device to the server. The server passes the dialogue to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated to accumulate the necessary information.

[1532] Fact Check

[1533] The server analyzes the collected data and sends a fact-check request to the generation AI. The generation AI checks the accuracy of the provided information by searching the internet and its internal database. If there is a discrepancy with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-check results and presents the correction suggestion to the user.

[1534] Content generation and real-time display

[1535] The server sends a content generation request to the generation AI based on the collected data and fact-checked data. The generation AI analyzes the data and generates appropriate product information and purchase suggestions. The generated content is sent to the device via the server, and the device displays it in real time on the smart glasses display.

[1536] Examples and prompts

[1537] Examples:

[1538] A user speaks, "I want the latest red smartphone."

[1539] The application responds, "Searching for the latest red smartphone..." and displays related products and pricing information on the smart glasses' display.

[1540] Example prompt sentence:

[1541] User says: "I want the latest red smartphone."

[1542] Prompt sent to the AI: "Search for product information on the latest red smartphone and suggest it to the user."

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

[1544] Step 1:

[1545] The user puts on the smart glasses and starts the application. A user ID and password entry screen appears on the smart glasses display. The user enters the user ID and password. The entered authentication information (user ID and password) is sent from the device to the server. The server compares the received authentication information with the database and generates an authentication result. If successful, it generates a session ID and sends a notification of successful authentication to the device, and if unsuccessful, it sends back an error message. (Input: user ID, password; Output: authentication result, session ID or error message)

[1546] Step 2:

[1547] Once user authentication is complete, the user begins a dialogue with the generated AI through the smart glasses. The user inquires about the system via voice input (e.g., "I want the latest red smartphone"). The voice data is converted into text data by the device and sent to the server. (Input: User voice input, Output: Text data)

[1548] Step 3:

[1549] The server passes the text data to the generation AI, which then generates a prompt that asks related questions and searches for product information. The generation AI then asks the user further questions based on the prompt to gather more detailed information. This interaction is repeated with additional input from the user. (Input: user text data, Output: prompt to the generation AI, next question from the generation AI)

[1550] Step 4:

[1551] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by referencing the internet and internal databases. Once the information has been verified, the fact-check results are returned to the server. (Input: collected data, output: fact-check results)

[1552] Step 5:

[1553] The fact-check results are analyzed, and if there is any contradictory data, the AI ​​generates correction suggestions and returns them to the server. The server then presents the fact-check results and correction suggestions to the user. (Input: Fact-check results, Output: Correction suggestions)

[1554] Step 6:

[1555] The server sends a content generation request to the generation AI based on the fact-checked data. The generation AI analyzes the data and generates content including optimal purchasing suggestions for the user. The generated content is sent to the device via the server, and the device displays it in real time on the smart glasses display. (Input: fact-checked data, Output: generated content)

[1556] Step 7:

[1557] If the user checks the generated content and wishes to proceed with the purchase, they send instructions to the server via their terminal. The server then confirms the purchase procedure, obtains the necessary information, and completes the process. (Input: User's purchase instructions, Output: Notification of purchase process completion)

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

[1559] MODE FOR CARRYING OUT THE INVENTION

[1560] The present invention provides a system including a user authentication means, a data collection means for interacting with a generation artificial intelligence, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, a digital and print file generation means, and an emotion engine for recognizing user emotions.

[1561] User Authentication

[1562] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal sends the entered authentication information to the server. The server queries the database for the received authentication information and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session, but if authentication fails, it returns an error message to the terminal.

[1563] Data collection

[1564] Once authentication is complete, the user begins a dialogue with the generation AI on the interface. The device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time. The server passes the dialogue content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated to accumulate the necessary information. The device also contains an emotion engine that recognizes emotions from the user's facial expressions and tone of voice. This allows the emotion engine to analyze the user's emotional state in real time. The emotion engine's analysis results are sent to the server and are used to adjust the dialogue content.

[1565] Fact Check

[1566] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by consulting the internet and internal databases. For example, if a user states that "a new product was a big hit in 2005," the generation AI checks that information against external sources. If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-check results and presents the correction suggestion to the user.

[1567] Content Generation

[1568] The server sends a request to the generative AI to create a draft structure for the autobiography based on the collected episodes and fact-checked data. The generative AI analyzes the data and determines the chapter structure, order, and placement of key episodes in the autobiography. For example, it generates chapters such as an introduction, career turning points, and a record of successes and failures. It also adjusts the tone and content of the text according to the user's emotional state. For example, if the user is excited, it generates powerful sentences that reflect that emotion. The generative AI returns the first draft to the server, which stores it in a database.

[1569] Proofreading and Layout

[1570] The server requests the generation AI and instructs it to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency and makes any necessary corrections. The generation AI then re-layouts the corrected document. The layout includes header file settings, font selection, and column settings. The server saves the completed document and layout in a database.

[1571] Cover creation

[1572] The user inputs the requirements for the cover design into the interface (e.g., "white text on a blue background"). The device sends the user's requirements to the server. The server requests the generation AI to create multiple cover design proposals. The generation AI generates the design proposals and returns them to the server. The server then presents the generated design proposals to the user. It is also possible to adjust the theme and colors of the cover design proposals based on the user's emotions recognized by the emotion engine. For example, if the user expresses an emotion of joy, a design using bright colors is suggested.

[1573] Final proofreading and polishing

[1574] A professional editor accesses the server using a device to review the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The professional editor incorporates the corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format or a file for printing.

[1575] Publication and Distribution

[1576] The server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server sends a notification of publication completion to the user and the professional editor. If desired, the user has access to a dashboard to monitor the sales status of the published book. The server collects sales data in real time and displays it on the dashboard.

[1577] The above is a detailed description of the embodiment of the present invention. By using this system, a high-quality autobiography that reflects the user's emotions can be created and published quickly and efficiently.

[1578] The processing flow will be explained below.

[1579] Step 1:

[1580] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal then sends the entered authentication information to the server.

[1581] Step 2:

[1582] The server queries the database for the authentication information it receives and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session. If authentication fails, an error message is returned to the terminal.

[1583] Step 3:

[1584] After authentication is complete, the user begins interacting with the generative AI on the interface, and the device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time.

[1585] Step 4:

[1586] The server passes the dialogue to the AI ​​generator, which then generates relevant and probing questions. The AI ​​then generates the next most appropriate question and sends it to the device.

[1587] Step 5:

[1588] The device analyzes the user's facial expressions and tone of voice in real time, and recognizes emotions using an emotion engine to detect emotional states (e.g., joy, sadness, excitement, etc.) and send the results to the server.

[1589] Step 6:

[1590] The user enters answers to questions, which are then sent to the server via the device. This process is repeated to accumulate the necessary information. The server then stores the dialogue log and emotion data in a database.

[1591] Step 7:

[1592] The server analyzes the collected data and sends a fact-check request to the Generator AI, which then checks the internet and its internal databases to verify the accuracy of the information provided.

[1593] Step 8:

[1594] If there is a contradiction with the confirmed data, the generation AI generates a correction suggestion and returns it to the server, which then updates the fact-checking results in the database and presents the correction suggestion to the user.

[1595] Step 9:

[1596] The server sends a request to the AI ​​generator to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The AI ​​generator then determines the chapter structure and order of the autobiography, as well as the placement of key episodes.

[1597] Step 10:

[1598] The AI ​​adjusts the tone and content of the text based on the user's emotional state. For example, if the user is excited, it will generate powerful text that reflects that emotion.

[1599] Step 11:

[1600] The generative AI sends the first draft back to the server, which stores it in a database.

[1601] Step 12:

[1602] The server requests the AI ​​to perform automatic proofreading, which checks grammar, spelling, and style consistency and makes any necessary corrections.

[1603] Step 13:

[1604] The generative AI then re-layouts the revised document, including header file settings, font selection, and column settings. The server then stores the completed document and layout in a database.

[1605] Step 14:

[1606] The user enters the requirements for the cover design into the interface (e.g., "white text on a blue background"), and the device sends the user's requirements to the server.

[1607] Step 15:

[1608] The server requests the AI ​​to create multiple cover design proposals, which the AI ​​then generates and returns to the server.

[1609] Step 16:

[1610] The server presents the generated design proposals to the user. It also adjusts the theme and color of the cover design proposal based on the user's emotions as recognized by the emotion engine. For example, if the user expresses joy, it suggests a design using bright colors.

[1611] Step 17:

[1612] The user selects a design of their choice and transmits the selection result to the server via the terminal.

[1613] Step 18:

[1614] A professional editor accesses the server using a terminal to check the generated document, layout, and cover design. If necessary, the professional editor performs final proofreading to optimize the document's style and consistency.

[1615] Step 19:

[1616] A professional editor will make the necessary edits and upload the final file to a server, which will then compile the finished file and generate a digital or print format.

[1617] Step 20:

[1618] The server uploads the final file to the publishing platform, and the server sends a notification of publication completion to the user and the professional editor.

[1619] Step 21:

[1620] If desired, users can access a dashboard to monitor the sales status of their published books. The server collects sales data in real time and displays it on the dashboard.

[1621] The above is a detailed description of the embodiment of the present invention. By using this system, a high-quality autobiography that reflects the user's emotions can be created and published quickly and efficiently.

[1622] Example 2

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

[1624] Conventional autobiography creation systems have the problem that it is difficult to generate high-quality content that reflects the user's emotions, and there is a lack of automated fact-checking and proofreading, making it difficult to create and publish autobiographies efficiently and accurately.

[1625] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a user authentication means, a data collection means for interacting with the generation AI, and a means for fact-checking the collected data. This makes it possible to efficiently generate high-quality content that reflects the user's emotions and ensure accuracy.

[1626] "User authentication means" refers to a means for verifying the identity of a user when accessing a system.

[1627] The "data collection means for interacting with the generating AI" is a means for collecting input from the user in real time and passing that data to the generating AI.

[1628] "Means for fact-checking collected data" refers to means for consulting the internet and internal databases to verify the accuracy of collected data.

[1629] "Means for automatically generating content" refers to means for automatically constructing and generating content such as an autobiography based on data collected by a generative artificial intelligence.

[1630] An "automated content proofreading solution" is a solution that checks generated content for grammar, spelling, and style consistency and makes any necessary corrections.

[1631] An "automatic layout generation method" is a method that automatically generates an appropriate layout for the composed content, including columns, fonts, header files, etc.

[1632] The "means for automatically generating a cover design" is a means for automatically generating an appropriate cover design based on requirements from a user.

[1633] "Means for final proofreading and correction" refers to a means for finally checking the generated content and design and making any necessary corrections.

[1634] "Means for generating digital and print files" means means for converting the finished content into a file format suitable for digital and print formatting.

[1635] "Means for recognizing a user's emotions in real time and using them to adjust the content of the dialogue and the generated content" refers to means for analyzing emotions from the user's facial expressions and tone of voice, and adjusting the content of the dialogue and the tone of the generated content based on the obtained emotional information.

[1636] The present invention is a system that includes means for user authentication, means for collecting data to interact with a generative artificial intelligence, means for fact-checking the collected data, means for automatically generating content, means for automatically proofreading the content, means for automatically generating layouts, means for automatically generating cover designs, means for final proofreading and corrections, means for generating digital and print files, and means for recognizing user emotions in real time and using them to adjust the content of the interaction and the generated content.

[1637] First, the user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password for user authentication. The terminal sends the entered authentication information to the server, and the server queries the received authentication information against a database for verification. If authentication is successful, the server generates a session ID, and if authentication fails, it returns an error message to the terminal.

[1638] Next, once authentication is complete, the user can begin a dialogue with the generation AI through the interface. The device sends the user's input to the server in real time, and the server passes the dialogue content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated to accumulate the necessary information. The device also contains an emotion engine that recognizes emotions from the user's facial expressions and tone of voice, and sends the emotion engine's analysis results to the server to help adjust the dialogue content.

[1639] For fact-checking, the server analyzes the collected data and sends a fact-check request to the generation AI. The generation AI checks the accuracy of the provided information by referencing the internet and internal databases. For example, it checks the content "A new product was a big hit in 2005." If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server then updates the database with the fact-check results and presents the correction suggestion to the user.

[1640] Next, the server sends a request to the generative AI to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The generative AI analyzes the data, determines the autobiography's chapter structure, order, and placement of key episodes, and adjusts the tone of the writing according to the user's emotional state. The generative AI returns the first draft to the server, which stores it in a database.

[1641] The server then requests the generation AI to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency, makes any necessary corrections, and then re-layouts the text. The server then saves the completed document and layout in a database.

[1642] Next, the user inputs the requirements for the cover design into the interface. For example, "white text on a blue background." The device sends this information to the server, which then requests the generation AI to create the cover design. The generation AI generates multiple design proposals and sends them to the server. The server then presents the generated design proposals to the user and adjusts the design based on the results of the emotion engine.

[1643] Finally, a professional editor accesses the server using a terminal to review the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The professional editor uploads the final file with the edits reflected to the server, which then converts the finished file into a digital format or a file for printing.

[1644] Finally, the server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server then notifies the user and the professional editor that publication is complete. If desired, the user can access a dashboard to monitor the sales status of the published book. The server collects sales data in real time and displays it on the dashboard.

[1645] Prompt Sentence Examples

[1646] "Can you please provide some Python code to authenticate a user using a user ID and password?"

[1647] "Can you provide some Python code to interact with the user to gather specific information?"

[1648] "Can you please give me some Python code to check the accuracy of given information on the internet?"

[1649] "Can you please provide some Python code that will generate a draft of an autobiography based on the collected data?"

[1650] "Can you please provide some Python code to automate proofreading and document layout?"

[1651] "Can you please give me some Python code to generate multiple cover design ideas based on given requirements?"

[1652] "Can you give me some Python code to proofread the document and generate a digital format?"

[1653] "Can you please provide me with the Python code to upload my digital files to a publishing platform? Also, how do I collect sales data and display it on a dashboard?"

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

[1655] Step 1: User authentication

[1656] A user accesses the system from a terminal and enters their user ID and password. The terminal sends the entered authentication information to the server. The server queries the database for the received authentication information and verifies it. If authentication is successful, the server generates a session ID, and if authentication fails, it returns an error message to the terminal.

[1657] Input: User ID, Password

[1658] Output: Session ID (if authentication is successful), Error message (if authentication is unsuccessful)

[1659] Specific behavior:

[1660] 1. The user visits the login page and enters their credentials.

[1661] 2. The device sends the authentication information to the server.

[1662] 3. The server performs a database check and returns the results to the terminal.

[1663] Step 2: Data collection

[1664] The user begins a dialogue with the generation AI. The device sends the user's input in real time to the server. The server passes the dialogue content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters a response, which is again sent to the server via the device. The device contains an emotion engine that recognizes emotions from the user's facial expressions and tone of voice, and sends the analysis results to the server.

[1665] Input: User text input, user facial expressions and tone of voice

[1666] Output: Questions from the generative AI, sentiment analysis results

[1667] Specific behavior:

[1668] 1. User types "We entered new markets in 2005."

[1669] 2. The device sends the input to the server.

[1670] 3. The server passes the dialogue to the generation AI, which generates related questions.

[1671] 4. The generating AI sends the question to the device.

[1672] 5. The emotion engine analyzes the user's emotions and sends the results to the server.

[1673] Step 3: Fact Check

[1674] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by searching the internet and its internal database. If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-checking results and presents the correction suggestion to the user.

[1675] Input: Collected data

[1676] Output: Fact check results, suggested corrections

[1677] Specific behavior:

[1678] 1. The server sends a fact-check request to the generating AI.

[1679] 2. The generating AI searches and checks the internet and internal databases.

[1680] 3. If there are any discrepancies, a correction proposal is created and sent to the server.

[1681] 4. The server presents the user with suggested revisions.

[1682] Step 4: Content Generation

[1683] The server sends a request to the generative AI to create a draft of the autobiography. The generative AI analyzes the data and determines the chapter structure, order, and placement of key episodes. It adjusts the tone of the text according to the user's emotional state. The generative AI returns the first draft to the server, which stores it in a database.

[1684] Input: Collected episodes, fact-checked data

[1685] Output: First draft of autobiography

[1686] Specific behavior:

[1687] 1. The server requests the generation AI to create a composition plan.

[1688] 2. The generative AI analyzes the data and determines the chapter structure and main episodes.

[1689] 3. The generative AI creates a first draft and sends it to the server.

[1690] Step 5: Proofreading and layout

[1691] The server requests the generation AI to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency and makes any necessary corrections. The generation AI then re-layouts the corrected document. The server saves the completed document and layout in a database.

[1692] Input: First draft

[1693] Output: Proofread, revised, and laid-out document

[1694] Specific behavior:

[1695] 1. The server asks the generation AI to proofread the text.

[1696] 2. The generative AI checks grammar and spelling and makes corrections.

[1697] 3. The generative AI reconstructs the revised document layout and sends it to the server.

[1698] Step 6: Create the cover

[1699] The user inputs the requirements for the cover design into the interface. The device sends the requirements to the server. The server requests the generation AI to create multiple cover design proposals. The generation AI generates the design proposals and sends them to the server. The server presents the generated design proposals to the user and adjusts them as needed based on the results of the emotion engine.

[1700] Input: Cover design requirements

[1701] Output: Cover design proposal

[1702] Specific behavior:

[1703] 1. The user enters the cover design requirements: "white text on a blue background."

[1704] 2. The device sends the requirements to the server.

[1705] 3. The server asks the generation AI to create a cover design proposal.

[1706] 4. The generative AI generates multiple design proposals and sends them to the server.

[1707] 5. The server presents design proposals to the user and makes adjustments based on sentiment analysis.

[1708] Step 7: Final proofreading and polishing

[1709] A professional editor accesses the server using a device to review the generated document, layout, and cover design. If necessary, a final proofread is performed to optimize the document's style and consistency. The professional editor incorporates the corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format or a file for printing.

[1710] Input: Generated document, layout, and cover design

[1711] Output: Final revised version, digital format, print file

[1712] Specific behavior:

[1713] 1. A professional editor will review the text, layout, and cover design.

[1714] 2. A professional editor performs a final proofread to optimize style and consistency.

[1715] 3. The professional editor makes the necessary changes and uploads the final file to the server.

[1716] 4. The server generates the digital format and print files.

[1717] Step 8: Publishing and Distribution

[1718] The server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server then sends a notification of publication completion to the user and the professional editor. The user can access a dashboard to monitor the sales status of the published book. The server collects real-time sales data and displays it on the dashboard.

[1719] Input: Final file

[1720] Output: Publication notification, sales data display

[1721] Specific behavior:

[1722] 1. The server uploads the final file to the publishing platform.

[1723] 2. The server sends a publication completion notification to the user and the professional editor.

[1724] 3. Users monitor sales on a dashboard.

[1725] 4. The server collects sales data in real time and displays it on the dashboard.

[1726] (Application example 2)

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

[1728] While there have been systems for efficiently creating autobiographies and personal documents, there has been no system that can consistently generate personalized content that reflects the user's emotional information, fact-check, and automate cover design. Furthermore, there has been a demand for a system that can utilize smart devices and enable users without specialized knowledge to easily create high-quality documents.

[1729] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes a user authentication means, a data collection means for interacting with the generation AI, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, a digital and print file generation means, an emotion engine means for recognizing the user's emotional state, and an application installed on the smart device. This enables the generation and distribution of a high-quality, personalized autobiography that reflects emotional information while the user interacts with it through the smart device.

[1730] "User authentication means" refers to a means of authenticating a user using a user ID and password when the user accesses the system.

[1731] The "data collection means for interacting with the generative artificial intelligence" is a means for collecting user input information in real time and supporting interaction with the generative artificial intelligence.

[1732] "Fact-checking tools" are tools that verify information using the internet and internal databases to confirm the accuracy of collected information.

[1733] The "automatic content generation means" is a means for automatically generating the structure and arrangement of episodes based on collected data.

[1734] An "automated content proofreader" is a means for automatically proofreading generated content for consistency of grammar, spelling, and style.

[1735] The "automatic layout generation means" is a means for automatically setting the layout of a document and generating a format and columns.

[1736] The "automatic cover design generation means" is a means for automatically generating a plurality of cover design proposals based on the user's requirements.

[1737] The "final proofreading and correction means" is a means by which a professional editor makes a final check of the generated content and makes any necessary corrections.

[1738] "Digital and print file generator" means a generator that generates finished content in digital format and print files.

[1739] The "emotion engine means for recognizing the user's emotional state" is a means for analyzing the user's emotions in real time from their facial expressions and tone of voice, and using this information to adjust the content of the dialogue.

[1740] An "application installed on a smart device" is an application that is installed on a device such as a smartphone or tablet and that can be operated intuitively by a user.

[1741] This invention is a system that operates in conjunction with a smart device and is composed of means including user authentication, data collection for interacting with a generation AI, fact checking, automatic content generation, automatic content proofreading, automatic layout generation, automatic cover design generation, final proofreading and correction, digital and print file generation, and an emotion engine.

[1742] The system uses the following specific hardware and software:

[1743] 1. Hardware:

[1744] Smart devices (e.g. smartphones, tablets)

[1745] 2. Software:

[1746] Server: Flask (Python)

[1747] Database: PostgreSQL

[1748] Generative AI model: OpenAI GPT-3

[1749] Emotion engine: Microsoft Azure Emotion API

[1750] When a user accesses the application using a smart device, they first undergo user authentication. If authentication is successful, the user begins a dialogue with the generation AI using a conversational interface. The information the user enters is sent to the server in real time, and the generation AI generates the next appropriate question, and the dialogue continues.

[1751] During this dialogue process, the emotion engine analyzes the user's emotions in real time from their facial expressions and tone of voice, and the analysis results are sent to the server, which then adjusts the content of the dialogue and the tone of the text based on that information.

[1752] The collected data is stored on a server and fact-checked using a generative AI. For example, if a user states, "A new product was a big hit in 2005," the generative AI verifies that information against external sources. After this fact-check, the generative AI automatically generates a draft structure for the autobiography. Based on the collected episodes and the data after the fact-check, it generates a draft structure including the chapter structure and episode placement.

[1753] The generated text is checked for grammar and style using an automatic proofreading means, and the document layout is set using an automatic layout generation means.When the user inputs their cover design requests, the generation AI generates multiple cover design proposals and uses an emotion engine to adjust the design theme and color according to the user's emotions.

[1754] Finally, a professional editor will do the final proofreading and editing, and the finished file will be generated in digital and print formats. This digital file will be uploaded to a publishing platform where users can monitor the sales of the published book.

[1755] As a specific example, when a user inputs an episode about entering a new market, the dialogue content is as follows:

[1756] User input: It was 2005 when we expanded into new markets.

[1757] Prompt for Generative AI: You entered a new market in 2005. What was the biggest challenge?

[1758] In this way, the system reflects the user's feelings and allows the user to easily create and publish a high-quality autobiography.

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

[1760] Step 1: User authentication

[1761] A user accesses an application using a smart device (smartphone or tablet) and enters their user ID and password. This authentication information is sent from the device to the server, which checks it against a database to determine whether the authentication was successful. If authentication is successful, the server generates a session ID and returns it to the device. If authentication is unsuccessful, it returns an error message. The input is the user ID and password, and the output is the session ID or an error message.

[1762] Step 2: Data collection

[1763] After authenticating, the user begins interacting with the generation AI through an interface. The user's input (e.g., "We entered a new market in 2005") is sent in real time from the device to the server. The server passes the input to the generation AI, which then generates the next appropriate question. This question is sent to the device, and the user enters an answer, which is then sent again from the device to the server. This process is repeated, accumulating the necessary data. The input is the user's interaction, and the output is the next question.

[1764] Step 3: Analysis by the Emotion Engine

[1765] The device includes an emotion engine that recognizes emotions from the user's facial expressions and tone of voice. This emotional information is sent to the server in real time and used to adjust the content of the dialogue. For example, if the user is excited, the tone and content of the questions generated are adjusted based on this emotional information. The input is the user's facial expressions and tone of voice, and the output is adjustment of the questions generated.

[1766] Step 4: Fact Check

[1767] The server performs fact-checking to verify the accuracy of the collected data. The generating AI checks the accuracy of the provided information by referencing the internet and internal databases. During this process, information such as "A new product was a big hit in 2005" is verified against external sources. The input is the collected data, and the output is fact-checked data.

[1768] Step 5: Content Generation

[1769] The server sends a request to the generation AI to create a draft structure for the autobiography based on the collected episodes and fact-checked data. The generation AI analyzes the data and determines the structure, order, and placement of key episodes in the autobiography. For example, it generates chapters such as an introduction, career turning points, and a record of successes and failures. The input is fact-checked data, and the output is a draft structure for the autobiography.

[1770] Step 6: Auto-Proofreading and Layout Generation

[1771] The server requests the generation AI to perform automatic proofreading of the created text. The generation AI checks grammar, spelling, and style consistency, and makes any necessary corrections. The generation AI then re-lays out the corrected document, setting up header files, selecting fonts, and setting columns. The input is a draft of the autobiography, and the output is the proofread and laid-out document.

[1772] Step 7: Create a cover design

[1773] The user inputs the cover design requirements (e.g., "white text on a blue background") into the interface, and the device sends the requirements to the server. The server then requests the generation AI to generate multiple cover design proposals. Based on the analysis results of the emotion engine, the design theme and colors are adjusted according to the user's emotions. The input is the cover design requirements and the user's emotional information, and the output is the generated cover design proposals.

[1774] Step 8: Final proofreading and polish

[1775] A professional editor accesses the server using a terminal and checks the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The final corrected file is uploaded to the server. The input is the proofread and layout document, and the output is the final checked and corrected document.

[1776] Step 9: Publishing and Distribution

[1777] The server uploads the final file to a publishing platform, for example to multiple digital publishing platforms simultaneously. The user is notified of successful publication and can access a sales dashboard if desired. The input is the final verified and revised document; the output is a successful publication notification and a sales dashboard.

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

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

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

[1781] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1795] MODE FOR CARRYING OUT THE INVENTION

[1796] The present invention provides a system including a user authentication means, a data collection means for interacting with a generation artificial intelligence, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, and a digital and print file generation means.

[1797] User Authentication

[1798] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal sends the entered authentication information to the server. The server queries the database for the received authentication information and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session, but if authentication fails, it returns an error message to the terminal.

[1799] Data collection

[1800] Once authentication is complete, the user begins interacting with the generation AI on the interface. The device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time. The server passes the interaction content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated until the necessary information is accumulated. The server saves the interaction log in a database.

[1801] Fact Check

[1802] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by consulting the internet and internal databases. For example, if a user states that "a new product was a big hit in 2005," the generation AI checks that information against external sources. If there is a contradiction with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-check results and presents the correction suggestion to the user.

[1803] Content Generation

[1804] The server sends a request to the generative AI to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The generative AI analyzes the data and determines the autobiography's chapter structure, order, and placement of key episodes. For example, it generates chapters such as an introduction, career turning points, and a record of successes and failures. The generative AI returns the first draft to the server, which stores it in a database.

[1805] Proofreading and Layout

[1806] The server requests the generation AI and instructs it to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency and makes any necessary corrections. The generation AI then re-layouts the corrected document. The layout includes header file settings, font selection, and column settings. The server saves the completed document and layout in a database.

[1807] Cover creation

[1808] The user inputs the requirements for the cover design into the interface (e.g., "white text on a blue background"). The device sends the user's requirements to the server. The server requests the generation AI to create multiple cover design proposals. The generation AI generates the design proposals and returns them to the server. The server presents the generated design proposals to the user. The user selects their preferred design and sends the selection to the server via the device.

[1809] Final proofreading and polishing

[1810] A professional editor accesses the server using a device to review the generated document, layout, and cover design. The professional editor performs final proofreading as needed to optimize the document's style and consistency. The professional editor incorporates the corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format or a file for printing.

[1811] Publication and Distribution

[1812] The server uploads the final file to a publishing platform, such as Amazon, Google Books, or Apple Books. The server sends a notification of publication completion to the user and the professional editor. If desired, the user has access to a dashboard to monitor the sales status of the published book. The server collects sales data in real time and displays it on the dashboard.

[1813] The above is a detailed description of the embodiment of the present invention. By using this system, an autobiography can be created and published quickly and efficiently.

[1814] The processing flow will be explained below.

[1815] Step 1:

[1816] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal then sends the entered authentication information to the server.

[1817] Step 2:

[1818] The server queries the database for the authentication information it receives and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session. If authentication fails, an error message is returned to the terminal.

[1819] Step 3:

[1820] After authentication is complete, the user begins interacting with the generative AI on the interface, and the device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time.

[1821] Step 4:

[1822] The server passes the dialogue to the AI ​​generator, which then generates relevant and probing questions. The AI ​​then generates the next most appropriate question and sends it to the device.

[1823] Step 5:

[1824] The user enters an answer, which is then sent to the server via the terminal. This process is repeated until all necessary information is accumulated. The server then saves the dialogue log in a database.

[1825] Step 6:

[1826] The server analyzes the collected data and sends a fact-check request to the Generator AI, which then checks the internet and its internal databases to verify the accuracy of the information provided.

[1827] Step 7:

[1828] If there is a contradiction with the confirmed data, the generation AI generates a correction suggestion and returns it to the server, which then updates the fact-checking results in the database and presents the correction suggestion to the user.

[1829] Step 8:

[1830] The server sends a request to the AI ​​to create a draft of the autobiography structure based on the collected episodes and fact-checked data. The AI ​​then determines the chapter structure and order, as well as the placement of key episodes, and generates a first draft.

[1831] Step 9:

[1832] The server requests the AI ​​to perform automatic proofreading, which checks grammar, spelling, and style consistency and makes any necessary corrections.

[1833] Step 10:

[1834] The generative AI then re-layouts the revised document, including header file settings, font selection, and column settings. The server then stores the completed document and layout in a database.

[1835] Step 11:

[1836] The user enters the requirements for the cover design into the interface (e.g., "white text on a blue background"), and the device sends the user's requirements to the server.

[1837] Step 12:

[1838] The server requests the AI ​​to create multiple cover design proposals, which the AI ​​then generates and returns to the server.

[1839] Step 13:

[1840] The server presents the generated design proposals to the user, who then selects the design they prefer and sends the selection to the server via their terminal.

[1841] Step 14:

[1842] A professional editor accesses the server using a terminal to check the generated document, layout, and cover design. The professional editor then performs a final proofread to optimize the document's style and consistency.

[1843] Step 15:

[1844] A professional editor will make the necessary edits and upload the final file to a server, which will then compile the finished file and generate a digital or print format.

[1845] Step 16:

[1846] The server uploads the final file to the publishing platform, and the server sends a notification of publication completion to the user and the professional editor.

[1847] Step 17:

[1848] If desired, users can access a dashboard to monitor the sales status of their published books. The server collects sales data in real time and displays it on the dashboard.

[1849] The above are the steps of the specific processing flow of the program.

[1850] Example 1

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

[1852] The traditional autobiography creation process is laborious, time-consuming, and often requires specialized knowledge. As a result, individuals who try to create their own autobiographies face many difficulties. To solve this problem, a system is needed to create and publish autobiographies efficiently and quickly by automating each step, including data collection, fact-checking, content creation, proofreading, layout, cover design, final proofreading, and digital and print file creation.

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

[1854] In this invention, the server includes a user authentication means, a data collection means for interacting with the generation AI, and a fact-checking means for analyzing the collected data and checking the authentication information, thereby enabling efficient user authentication and highly reliable data collection and verification.

[1855] "User authentication means" is a means for verifying that a user is a legitimate user when accessing a system.

[1856] The "data collection means for interacting with the generative artificial intelligence" is a means for collecting necessary information through interaction with the user.

[1857] "Fact-checking measures" are measures used to verify the accuracy and veracity of collected data.

[1858] The "automatic content generation means" is a means for automatically generating content based on collected data.

[1859] An "automated content proofreader" is a tool for checking and correcting the consistency of grammar, spelling, and style of generated content.

[1860] The "automatic layout generation means" is a means for automatically generating a page layout based on the proofread content.

[1861] The "automatic cover design generation means" is a means for automatically generating a cover design based on the user's requirements.

[1862] "Final proofreading and correction means" refers to the means for finally checking and correcting the generated content, layout, and cover design.

[1863] "Digital and print file generation means" means for generating the final completed document or design as a digital file and a print file.

[1864] The present invention is a system including a user authentication means, a data collection means for interacting with a generation artificial intelligence, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, and a digital and print file generation means. By using this system, users can efficiently create and publish their autobiographies.

[1865] User Authentication

[1866] A user accesses the system's web page using their own PC or smartphone. The terminal displays an interface and the user enters their user ID and password. For example, the user ID is "user123" and the password is "password123." The terminal encrypts this authentication information and sends it to the server. The server queries its database for the received authentication information, and if matching information is found, it generates a session ID and notifies the start of the session.

[1867] Data collection

[1868] After authentication is complete, the user moves to the dialogue interface and begins a dialogue with the generation AI. For example, they might enter, "We entered a new market in 2005." The device sends this input in real time to the server, which then passes it on to the generation AI. The generation AI then generates related and probing questions (e.g., "Which markets did you enter?"), which the server receives and sends to the device. By repeating this process, the necessary information is accumulated, and the dialogue log is stored in a database.

[1869] Fact Check

[1870] The server analyzes the collected data and sends a fact-checking request to the generation AI. For example, to check a claim such as "The new product was a big hit in 2005," the generation AI consults the internet and internal databases. It verifies the information against external sources and, if there is a discrepancy, generates a correction suggestion and sends it to the server. For example, a correction suggestion might be "The new product was a big hit in 2006, not 2005." The server updates the database and notifies the user of the correction suggestion.

[1871] Content Generation

[1872] Once the fact-checking is complete, the server sends a request to the generative AI to create a draft of the autobiography structure based on the collected anecdotes and verified data. The generative AI analyzes the data and determines the chapter structure, such as an introduction, career turning points, and a record of successes and failures. For example, the chapters might be "Introduction," "Career Shift," and "Success Stories." The generative AI creates a first draft and sends it to the server, where it is stored in a database.

[1873] Content proofing and layout

[1874] The server requests the generation AI to automatically proofread the created text. The generation AI checks grammar, spelling, and style consistency, and makes any necessary corrections. For example, it adds punctuation to change "successfully" to "successfully." The generation AI then lays out the proofread text. The layout includes header settings, font selection, column settings, etc. The server saves the completed document and layout in a database.

[1875] Cover creation

[1876] The user inputs the requirements for the cover design into the interface. For example, they specify "white text on a blue background." The device sends this to the server, which then requests the AI ​​to generate a cover design proposal. The server receives the generated design proposals and presents them to the user. The user then selects their preferred design and sends the results to the server via the device.

[1877] Final proofreading and polishing

[1878] A professional editor accesses the server via a device to review the generated document, layout, and cover design. A final proofreading is performed to optimize the document's style and consistency. The professional editor incorporates any corrections and uploads the final file to the server. The server organizes the finished file and generates a digital format and a file for printing.

[1879] Publication and Distribution

[1880] The server uploads the final file to a publishing platform, such as an online bookstore, and sends a notification of publication completion to the user and the professional editor. Optionally, the user can access a dashboard to monitor sales of the published book. The server collects sales data in real time and displays it on the dashboard.

[1881] Examples of concrete examples and prompts

[1882] Examples:

[1883] User types, "In 2005, we entered a new market."

[1884] The generative AI generates the question, "Which markets have you expanded into?"

[1885] Fact check example: "The new product became a big hit in 2006, not 2005" generates a correction suggestion.

[1886] Cover design requirements: "White text on a blue background."

[1887] Example prompt sentence:

[1888] "Prompt for user ID and password authentication. Example: User ID = 'user123', Password = 'password123'"

[1889] "A prompt that generates an appropriate question based on user input. Example: User input = 'We entered new markets in 2005'"

[1890] "A prompt that fact-checks information stated by the user. Example: User input = 'A new product became a big hit in 2005.'"

[1891] "A prompt that generates cover design ideas based on user requirements. Example: requirement = 'white text on blue background'"

[1892] The above is a detailed description of the embodiment of the present invention. This system allows users to efficiently create and publish their own autobiographies using advanced AI technology.

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

[1894] Step 1:

[1895] A user accesses the system's web page using their own terminal. The interface is displayed and they enter their user ID and password. Input information:

[1896] User ID (e.g., user123)

[1897] Password (e.g. password123)

[1898] What it does: You enter your user ID and password into a form, which starts the authentication process.

[1899] Step 2:

[1900] The terminal encrypts the entered authentication information and sends it to the server.

[1901] input:

[1902] Encrypted user ID and password

[1903] How it works: Authentication information is transmitted using the HTTPS protocol, which ensures a high level of security.

[1904] Step 3:

[1905] The server queries the database for the authentication information it receives and verifies it.

[1906] input:

[1907] Encrypted user ID and password

[1908] What it does: Runs an SQL query against the database to find records that match the input information.

[1909] output:

[1910] Match result (success or failure)

[1911] Step 4:

[1912] If authentication is successful, the server generates a session ID and notifies the terminal of the start of the session. If authentication fails, the server returns an error message to the terminal.

[1913] input:

[1914] Matching results

[1915] Behavior: Generates a session ID (e.g., ABC123) and generates a session start message or an error message.

[1916] output:

[1917] Session ID or error message

[1918] Step 5:

[1919] After authentication is complete, the user accesses the dialogue interface and begins dialogue with the generated AI.

[1920] input:

[1921] Authentication successful (Session ID)

[1922] Action: A dialog interface is displayed allowing the user to enter information.

[1923] Step 6:

[1924] The user inputs information into the dialogue interface, for example, "We entered a new market in 2005," and the device sends the input to the server.

[1925] input:

[1926] User input (e.g., "We expanded into new markets in 2005")

[1927] Operation: Input information is sent to the server in real time.

[1928] Step 7:

[1929] The server passes the user's input to the generation AI, which generates related and probing questions.

[1930] input:

[1931] User Input

[1932] How it works: The generation AI runs a prompt to generate a question.

[1933] output:

[1934] Generated questions (e.g., "Which markets have you expanded into?")

[1935] Step 8:

[1936] The server receives the questions generated by the generation AI and sends them to the device.

[1937] input:

[1938] Generated Questions

[1939] Action: Sends the question to the terminal and displays it to the user.

[1940] output:

[1941] The question shown to the user

[1942] Step 9:

[1943] The user answers the generated question and the terminal sends the answer back to the server.

[1944] input:

[1945] User response (e.g., "We have expanded into the Asian market")

[1946] Action: Sends the user's answer to the server.

[1947] Step 10:

[1948] This process is repeated until all necessary information is accumulated. The server stores all interaction logs in a database.

[1949] input:

[1950] User Answers

[1951] What it does: Saves the interaction log to a database.

[1952] output:

[1953] Interaction logs stored in a database

[1954] Step 11:

[1955] The server analyzes the collected data and sends a fact-checking request to the generating AI.

[1956] input:

[1957] Data collected

[1958] What it does: Runs a prompt that asks the generating AI to fact-check something.

[1959] output:

[1960] Fact-check request

[1961] Step 12:

[1962] The generating AI will check the internet and internal databases to verify the accuracy of the information provided.

[1963] input:

[1964] Fact-checked data

[1965] What it does: Validates data against external sources.

[1966] output:

[1967] Verification result (correct / incorrect)

[1968] Step 13:

[1969] If there is a discrepancy with the verified data, the generation AI generates correction suggestions and sends them to the server.

[1970] input:

[1971] confirmation result

[1972] Behavior: If there are any conflicts, generate correction suggestions.

[1973] output:

[1974] Revision suggestions

[1975] Step 14:

[1976] The server reflects the fact-check results in the database and notifies the user of suggested corrections.

[1977] input:

[1978] Revision suggestions

[1979] Action: Update the database and notify the user.

[1980] output:

[1981] Notification of proposed amendments

[1982] Step 15:

[1983] The server sends a request to the generation AI to create a draft of the autobiography structure based on the collected episodes and fact-checked data.

[1984] input:

[1985] Episodes and fact-checked data

[1986] Behavior: Executes a prompt to ask the generation AI to create a configuration.

[1987] output:

[1988] Request for composition plan

[1989] Step 16:

[1990] A generative AI analyzes the data and determines the autobiography's chapter structure, order, and placement of key episodes.

[1991] input:

[1992] Request for composition plan

[1993] What it does: Analyzes data and generates configuration suggestions.

[1994] output:

[1995] Chapter structure (e.g., "Introduction," "Career Turning Points," "Record of Successes and Failures")

[1996] Step 17:

[1997] The generative AI sends the initial draft to the server, which stores it in a database.

[1998] input:

[1999] first draft

[2000] What it does: Saves the first draft to the database.

[2001] output:

[2002] Saved first draft

[2003] Step 18:

[2004] The server requests the generation AI to automatically proofread the created text.

[2005] input:

[2006] Saved first draft

[2007] Behavior: Executes a prompt to ask the generating AI to perform auto-calibration.

[2008] output:

[2009] Automatic proofreading request

[2010] Step 19:

[2011] Generative AI checks grammar, spelling, and style consistency, and makes any necessary corrections.

[2012] input:

[2013] first draft

[2014] What it does: Checks and corrects grammar and spelling.

[2015] output:

[2016] Corrected text

[2017] Step 20:

[2018] The generation AI will then re-layout the revised text, setting headers, selecting fonts, and setting columns.

[2019] input:

[2020] Corrected text

[2021] Action: Lays out the text.

[2022] output:

[2023] Layout text

[2024] Step 21:

[2025] The server stores the completed document and layout in a database.

[2026] input:

[2027] Layout text

[2028] What it does: Saves documents and layouts to a database.

[2029] output:

[2030] Saved Documents and Layouts

[2031] Step 22:

[2032] The user enters the cover design requirements into the interface, for example, specifying "white text on a blue background."

[2033] input:

[2034] Cover design requirements

[2035] Action: Enter design requirements into the interface.

[2036] output:

[2037] Design Requirements

[2038] Step 23:

[2039] The terminal sends the user's requirements to the server.

[2040] input:

[2041] Design Requirements

[2042] Action: Sends requirements to the server.

[2043] output:

[2044] Submitted requirements

[2045] Step 24:

[2046] The server requests the generation AI to create a cover design proposal.

[2047] input:

[2048] Submitted requirements

[2049] Action: Prompt the generation AI to create a cover design proposal.

[2050] output:

[2051] Request for cover design proposal

[2052] Step 25:

[2053] The generation AI generates multiple cover design ideas and sends them to the server.

[2054] input:

[2055] Request for cover design proposal

[2056] What it does: Generate multiple design ideas.

[2057] output:

[2058] Design proposal

[2059] Step 26:

[2060] The server presents the generated design proposal to the user.

[2061] input:

[2062] Design proposal

[2063] What it does: Displays design suggestions to the user.

[2064] output:

[2065] The proposed design

[2066] Step 27:

[2067] The user selects a design of their choice and transmits the selection result to the server via the terminal.

[2068] input:

[2069] Design selection results

[2070] Action: Sends the selection results to the server.

[2071] output:

[2072] Submitted selection results

[2073] Step 28:

[2074] A professional editor uses a terminal to access the server and check the generated document, layout, and cover design.

[2075] input:

[2076] Generated document, layout and cover design

[2077] How it works: A professional editor reviews the content.

[2078] Step 29:

[2079] A professional editor will perform a final proofreading if necessary to optimize the document for style and consistency, and then the final file will be uploaded to the server after any corrections have been implemented.

[2080] input:

[2081] Document and layout, cover design

[2082] Action: Final proofreading and corrections.

[2083] output:

[2084] Final File

[2085] Step 30:

[2086] The server compiles the finished files and generates the digital format and print files.

[2087] input:

[2088] Final File

[2089] What it does: Generates digital and print files.

[2090] output:

[2091] Digital and print files

[2092] This allows the entire process from writing to publishing an autobiography to be efficiently automated.

[2093] (Application example 1)

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

[2095] In today's virtual stores, users need to be able to quickly and accurately obtain product information. Conventional systems make it difficult for users to gather information, resulting in a long wait time before obtaining the information they need, or they run the risk of obtaining inaccurate information. Under these circumstances, there is a need to provide accurate product information in real time to improve the user's purchasing experience. Furthermore, it is necessary to ensure a smooth purchasing process by quickly responding to user input and making appropriate suggestions.

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

[2097] In this invention, the server includes a user authentication means, a data collection means for interacting with the generating AI, and a fact-checking means. This allows users to obtain accurate product information in real time. Furthermore, by utilizing the content generation and display means, the shopping experience in the virtual store can be improved, facilitating the user's purchasing process.

[2098] "User authentication means" is a function for identifying and authenticating users who access the system.

[2099] The "data collection means for interacting with the generative artificial intelligence" is a function for collecting input information from the user and interacting with the generative artificial intelligence based on that information.

[2100] "Fact-checking tools" are functions that utilize external and internal databases to verify the accuracy of collected information.

[2101] The "automatic content generation means" is a function that automatically generates content based on collected data.

[2102] The "automatic content proofreading means" is a function that automatically checks and corrects the grammar and style of the generated content.

[2103] The "automatic layout generation means" is a function that automatically formats the appearance and structure of the generated content.

[2104] The "automatic cover design generation means" is a function that automatically creates a cover design based on specified requirements.

[2105] "Final proofreading and correction means" refers to a function that allows professionals to finally proofread and correct the generated content.

[2106] "Digital and print file generator" means a function for generating files in digital or print format for the final content.

[2107] The "content generation and display means" is a function for displaying the generated content on a display device in real time.

[2108] MODE FOR CARRYING OUT THE INVENTION

[2109] Program Overview

[2110] A system based on this application example is implemented using the following hardware and software components:

[2111] Hardware: Smart glasses (e.g. Microsoft HoloLens, Google Glass, etc.)

[2112] Software: Python 3.x, Requests library, SDK for smart glasses

[2113] Program processing explanation

[2114] User Authentication

[2115] The user puts on the smart glasses and starts the application. When the user enters their user ID and password, the device sends the entered authentication information to the server. The server checks the received authentication information against a database for verification. If authentication is successful, the server generates a session ID and notifies the device of successful authentication. If authentication fails, the server returns an error message to the device.

[2116] Data collection

[2117] Once user authentication is complete, the user begins a dialogue with the generation AI through the smart glasses interface. The user's voice input (e.g., "I want the latest red smartphone") is sent in real time by the device to the server. The server passes the dialogue to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated to accumulate the necessary information.

[2118] Fact Check

[2119] The server analyzes the collected data and sends a fact-check request to the generation AI. The generation AI checks the accuracy of the provided information by searching the internet and its internal database. If there is a discrepancy with the verified data, the generation AI generates a correction suggestion and returns it to the server. The server updates the database with the fact-check results and presents the correction suggestion to the user.

[2120] Content generation and real-time display

[2121] The server sends a content generation request to the generation AI based on the collected data and fact-checked data. The generation AI analyzes the data and generates appropriate product information and purchase suggestions. The generated content is sent to the device via the server, and the device displays it in real time on the smart glasses display.

[2122] Examples and prompts

[2123] Examples:

[2124] A user speaks, "I want the latest red smartphone."

[2125] The application responds, "Searching for the latest red smartphone..." and displays related products and pricing information on the smart glasses' display.

[2126] Example prompt sentence:

[2127] User says: "I want the latest red smartphone."

[2128] Prompt sent to the AI: "Search for product information on the latest red smartphone and suggest it to the user."

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

[2130] Step 1:

[2131] The user puts on the smart glasses and starts the application. A user ID and password entry screen appears on the smart glasses display. The user enters the user ID and password. The entered authentication information (user ID and password) is sent from the device to the server. The server compares the received authentication information with the database and generates an authentication result. If successful, it generates a session ID and sends a notification of successful authentication to the device, and if unsuccessful, it sends back an error message. (Input: user ID, password; Output: authentication result, session ID or error message)

[2132] Step 2:

[2133] Once user authentication is complete, the user begins a dialogue with the generated AI through the smart glasses. The user inquires about the system via voice input (e.g., "I want the latest red smartphone"). The voice data is converted into text data by the device and sent to the server. (Input: User voice input, Output: Text data)

[2134] Step 3:

[2135] The server passes the text data to the generation AI, which then generates a prompt that asks related questions and searches for product information. The generation AI then asks the user further questions based on the prompt to gather more detailed information. This interaction is repeated with additional input from the user. (Input: user text data, Output: prompt to the generation AI, next question from the generation AI)

[2136] Step 4:

[2137] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of the provided information by referencing the internet and internal databases. Once the information has been verified, the fact-check results are returned to the server. (Input: collected data, output: fact-check results)

[2138] Step 5:

[2139] The fact-check results are analyzed, and if there is any contradictory data, the AI ​​generates correction suggestions and returns them to the server. The server then presents the fact-check results and correction suggestions to the user. (Input: Fact-check results, Output: Correction suggestions)

[2140] Step 6:

[2141] The server sends a content generation request to the generation AI based on the fact-checked data. The generation AI analyzes the data and generates content including optimal purchasing suggestions for the user. The generated content is sent to the device via the server, and the device displays it in real time on the smart glasses display. (Input: fact-checked data, Output: generated content)

[2142] Step 7:

[2143] If the user checks the generated content and wishes to proceed with the purchase, they send instructions to the server via their terminal. The server then confirms the purchase procedure, obtains the necessary information, and completes the process. (Input: User's purchase instructions, Output: Notification of purchase process completion)

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

[2145] MODE FOR CARRYING OUT THE INVENTION

[2146] The present invention provides a system including a user authentication means, a data collection means for interacting with a generation artificial intelligence, a fact-checking means, an automatic content generation means, an automatic content proofreading means, an automatic layout generation means, an automatic cover design generation means, a final proofreading and correction means, a digital and print file generation means, and an emotion engine for recognizing user emotions.

[2147] User Authentication

[2148] The user accesses the system from a terminal (PC, smartphone, etc.) and enters their user ID and password. The terminal sends the entered authentication information to the server. The server queries the database for the received authentication information and verifies it. If authentication is successful, the server generates a session ID and notifies the start of the session, but if authentication fails, it returns an error message to the terminal.

[2149] Data collection

[2150] Once authentication is complete, the user begins a dialogue with the generation AI on the interface. The device sends the user's input (e.g., "We entered new markets in 2005") to the server in real time. The server passes the dialogue content to the generation AI, which generates related and probing questions. The generation AI then generates the next most appropriate question and sends it to the device. The user enters an answer, which is again sent to the server via the device. This process is repeated to accumulate the necessary information. The device also contains an emotion engine that recognizes emotions from the user's facial expressions and tone of voice. This allows the emotion engine to analyze the user's emotional state in real time. The emotion engine's analysis results are sent to the server and are used to adjust the dialogue content.

[2151] Fact Check

[2152] The server analyzes the collected data and sends a fact-checking request to the generation AI. The generation AI checks the accuracy of th...

Claims

1. User authentication means; a data collection means for interacting with the generative artificial intelligence; Fact-checking tools, An automatic content generation means; a content automatic proofreading means; automatic layout generation means; A cover design automatic generation means; Final proofreading and correction measures; Digital and print file generation tools Including system.

2. 10. The system of claim 1, further comprising means for collecting details of episodes or events through user interaction and storing them in a database.

3. 10. The system of claim 1, including fact-checking means that uses the Internet and internal databases to verify the accuracy of the collected information.

4. 2. The system according to claim 1, further comprising means for automatically generating content by using a generative artificial intelligence to determine the chapter structure, order and arrangement of main episodes of the autobiography.

5. 2. The system of claim 1, further comprising means for checking the generated text for grammar, spelling and style consistency using the automatic proofreading means and making any necessary corrections.

6. 2. The system according to claim 1, further comprising means for generating a plurality of cover design proposals based on user requirements and presenting them to the user.

7. 10. The system of claim 1, further comprising means for a professional editor to perform final proofreading and corrections and convert the finished file into a digital format or a file for printing.

8. The system of claim 1, further comprising means for uploading the generated autobiography to a publishing platform and providing a dashboard for monitoring sales. The above is the draft of the patent claims for the characteristic parts of the system.

Images