System

Abstract

A system is provided.SOLUTION: This system is provided with a means for receiving a document file prepared by a user, a means for confirming that the received document file is a prescribed form, a means for analyzing and extracting text data from the document file, a means for generating a program code based on the extracted text data and a means for outputting the generated program code.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] In recent years, creating web pages has required advanced knowledge of HTML, CSS, and JavaScript. However, it is extremely difficult for individuals or small organizations without this knowledge to create attractive web pages. In particular, there is a need for a method to quickly and easily generate web pages from existing document files (such as PDFs or presentation files). The present invention aims to solve these problems and provide a means for easily creating rich web pages without specialized knowledge. [Means for solving the problem]

[0005] The present invention provides a system including: means for receiving a document file created by a user; means for verifying that the received document file is in a predetermined format; means for analyzing and extracting text data from the document file; means for generating program code based on the extracted text data; and means for outputting the generated program code. The document file is in the format of a PDF or presentation file, and a machine learning model is used to convert the analyzed text data into program code, allowing the user to easily generate a web page.

[0006] A "user" is a person or organization that uses the system.

[0007] "Document file" refers to an electronic file that contains text data, such as a PDF or presentation file (e.g., PPTX).

[0008] The "receiving means" refers to a device or program for receiving a document file sent from a user.

[0009] "Prescribed format" means the PDF or presentation file format that the system can handle.

[0010] The "verification means" refers to a device or program that has the function of checking whether a received document file is in a predetermined format.

[0011] "Means for analyzing and extracting" refers to a device or program for extracting text data from a document file.

[0012] "Program Code" means the HTML, CSS, JavaScript, and other code required to generate a web page.

[0013] "Means for generating" refers to a device or program for generating program code based on the extracted text data.

[0014] The term "output means" refers to a device or program for providing the generated program code to a user.

[0015] A "presentation file" refers to an electronic file created primarily for the purpose of visually presenting information in the form of slides.

[0016] "Machine learning model" means an algorithm or system that learns from data and makes predictions or classifications based on new data. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0025] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0038] This system allows users to easily generate rich web pages using document files they have created. The system has the following main functions:

[0039] 1. Receiving document files

[0040] The user uploads the PDF or presentation file they created to the system. At this time, the terminal selects the file and sends it to the server. The server receives the HTTP request and temporarily stores the file.

[0041] 2. Check the format of the document file

[0042] The server checks whether the received file is a PDF or presentation file (e.g., PPTX). This allows it to process only compatible formats. The server checks the file extension and returns an error message for files that are not in the required format.

[0043] 3. Document file analysis and text extraction

[0044] The server selects the appropriate parsing method depending on the received file format and extracts text data from the document file. For PDF files, it uses the pdfminer library to extract text. For presentation files, it uses the python-pptx library to extract the text of each slide.

[0045] 4. Generate program code

[0046] The server generates program code based on the extracted text data. Specifically, it uses OpenAI's API to automatically generate HTML, CSS, and JavaScript code. The generated code is essential for providing the appearance and functionality of the web page.

[0047] 5. Generated Code Output

[0048] The generated program code is sent from the server to the user's device, where it is displayed in a browser and can be downloaded or copied by the user.

[0049] The following is a concrete example of this system:

[0050] Example 1: Creating a web page from a PDF file

[0051] A user creates a PDF file named "example.pdf" and uploads it to the system. The server receives the file and verifies that it is in PDF format. It then uses the pdfminer library to extract the text data and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's device, where it can be used as a web page.

[0052] Example 2: Generating a web page from a presentation file

[0053] A user creates a presentation file named "example.pptx" and uploads it to the system. The server receives the file and verifies that it is a presentation file. It then uses the python-pptx library to extract the text from each slide and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's device, where it can be used as a web page.

[0054] This concludes the description of the present invention. The system allows users to quickly and easily create rich web pages without specialized coding skills.

[0055] The processing flow will be explained below.

[0056] Step 1: Prepare a user-created PDF or presentation file.

[0057] A user creates a PDF or presentation file to represent the design of a web page, for example, a file called "example.pptx."

[0058] Step 2: Upload the prepared file to the server.

[0059] The user accesses the system, selects the file from the interface for uploading the created file, and clicks the upload button.

[0060] Step 3: The device sends the selected file to the server.

[0061] The device sends the file selected by the user to the server as an HTTP POST request, with the destination endpoint being " / upload."

[0062] Step 4: The server receives the file and stores it temporarily.

[0063] The server receives the HTTP request and saves the uploaded file (e.g., "example.pptx") in a temporary directory (e.g., " / tmp").

[0064] Step 5: The server checks the file format.

[0065] The server checks the file extension of the saved file to ensure it is a PDF or presentation file (e.g., PPTX), and generates an error message for any other file type.

[0066] Step 6: The server parses the file and extracts the text data.

[0067] The server extracts the text data using an appropriate library depending on the file format.

[0068] For PDF files, the server uses the pdfminer library to extract the text.

[0069] For presentation files, the server uses the python-pptx library to extract the text of each slide.

[0070] Step 7: The server generates program code based on the extracted text data.

[0071] The server sends the extracted text data to OpenAI's API and generates program code (HTML, CSS, JavaScript) by specifying a prompt such as "Please generate HTML and CSS code."

[0072] Step 8: The server outputs the generated program code to the user terminal.

[0073] The server packages the generated program code in JSON format and returns it to the user's device as an HTTP response.

[0074] Step 9: The terminal displays the code received from the server.

[0075] The terminal displays the received program code on a user interface, allowing the user to download or copy the code.

[0076] Step 10: The user creates a web page using the code they received.

[0077] Users can incorporate the displayed program code into their own web projects, edit and adjust it as needed, and complete a rich web page.

[0078] In this way, the system helps users automatically generate rich web pages from existing document files without requiring specialized knowledge.

[0079] Example 1

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

[0081] There is a demand for a system that allows users to quickly and easily generate rich web pages from document files they have created without having specialized coding skills. Conventional methods require specialized knowledge and time to extract text data from document files and convert it into web page code. The challenge is to solve this problem and provide a method that allows users to easily generate web pages.

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

[0083] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for using a generative model to generate program code based on the extracted text data, and means for outputting the generated program code, thereby enabling users to quickly and easily create rich web pages without specialized coding skills.

[0084] "User" refers to any individual or entity that intends to use the System to generate a Web page from a document file.

[0085] "Document File" refers to a PDF file or electronic slideshow file (presentation file) created by a User and uploaded to the System.

[0086] "Means for receiving" refers to the method or process by which the server receives the document file sent from the user's terminal.

[0087] "Means for verifying" refers to the method or process for verifying that the format of the document file received by the server is in the specified format (PDF or electronic slideshow file).

[0088] "Means for analyzing and extracting" refers to the method or process by which the server analyzes the contents of the document file and extracts text data therefrom.

[0089] "Means of using a generative model" refers to the method or process for generating program code (HTML, CSS, JavaScript) using a generative AI model based on extracted text data.

[0090] "Means for outputting" refers to a method or process for providing the generated program code to the user.

[0091] The "predetermined format" refers to a file format that the system can handle, specifically a PDF format or an electronic slideshow file format (presentation file format).

[0092] A "generative model" refers to a machine learning or artificial intelligence model used to generate program code based on text data.

[0093] A "prompt statement" is a document or instruction that is input to a generative model and is used to specify the content and format of the program code to be generated.

[0094] This invention relates to a system for generating rich web pages from document files created by users. The system provides a series of processes that allow users to upload document files and automatically generate code for web pages from those files.

[0095] System Configuration

[0096] Hardware

[0097] The system consists of the following hardware:

[0098] 1. Server: Receives files, analyzes them, inputs them into the generative model, generates program code, and outputs it.

[0099] 2. Terminal: The user uploads a document file and receives and displays the generated web page code.

[0100] software

[0101] The system consists of the following software:

[0102] 1. File receiving module: Receives document files uploaded by users.

[0103] 2. Format Verification Module: Verifies that the received file is in the required format (PDF or electronic slideshow file).

[0104] 3. Text Extraction Module: Analyzes the content of document files and extracts text data. Specifically, it uses the pdfminer library for PDF files and the python-pptx library for presentation files.

[0105] 4. Code generation module: Generates HTML, CSS, and JavaScript program code based on the extracted text data using a generative AI model. The generative model uses OpenAI's API.

[0106] 5. Code output module: Provides the generated program code to the user.

[0107] Example of operation

[0108] Example 1: Creating a web page from a PDF file

[0109] 1. A user creates a PDF file called "example.pdf" and uploads it to the system via the terminal.

[0110] 2. The server uses the file receiving module to receive the file and the format confirmation module to confirm that it is in PDF format.

[0111] 3. The server uses the pdfminer library to extract text data from the PDF file.

[0112] 4. Based on the extracted text data, generate a prompt sentence like the following and input it into the generative model:

[0113] Given the following user-provided text, generate HTML, CSS, and JavaScript code for a rich web page.

[0114] Text data: "Extracted text goes here."

[0115] 5. The generative AI model generates HTML, CSS, and JavaScript code based on the input prompt.

[0116] 6. The server receives the generated code and sends it to the terminal using the code output module.

[0117] 7. The user receives the web page code generated on their device and can view it in their browser or download it for use.

[0118] Example 2: Generating a web page from a presentation file

[0119] 1. A user creates a presentation file called "example.pptx" and uploads it to the system through the terminal.

[0120] 2. The server receives the file using the file receiving module and verifies that it is in presentation file format using the format verification module.

[0121] 3. The server uses the python-pptx library to extract text data from each slide in the presentation file.

[0122] 4. Based on the extracted text data, generate a prompt sentence like the following and input it into the generative model:

[0123] Given the following user-provided text, generate HTML, CSS, and JavaScript code for a rich web page.

[0124] Text data: "Extracted text goes here."

[0125] 5. The generative AI model generates HTML, CSS, and JavaScript code based on the input prompt.

[0126] 6. The server receives the generated code and sends it to the terminal using the code output module.

[0127] 7. The user receives the web page code generated on their device and can view it in their browser or download it for use.

[0128] The system allows users to quickly and easily create rich web pages without specialized coding skills.

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

[0130] Step 1:

[0131] The user selects a document file and uploads it to the system. The input includes the PDF or presentation file selected by the user. The output is the selected file sent to the server.

[0132] Specific behavior:

[0133] The user clicks the file selection button and a file selection dialog appears.

[0134] The user selects a document file (e.g., "example.pdf") and clicks the "Open" button.

[0135] The device sends the selected file to the server via an HTTP POST request.

[0136] Step 2:

[0137] The server checks the format of the document file received. The input includes the file extension. The output is a determination of whether the format is a specified format (PDF or presentation file).

[0138] Specific behavior:

[0139] Extract the extension of the file received by the server.

[0140] Check that the extracted file extension is ".pdf" or ".pptx".

[0141] If it is not in a supported format, the server generates an error message and returns it to the user.

[0142] Step 3:

[0143] The server analyzes the contents of document files to extract text data. The inputs include PDF or presentation files. The output is the extracted text data.

[0144] Specific behavior:

[0145] The server calls the appropriate library depending on the file format.

[0146] For PDF files, it uses the pdfminer library to extract text from each page.

[0147] For presentation files, we use the python-pptx library to extract the text from each slide.

[0148] The extracted text data is stored in memory.

[0149] Step 4:

[0150] The server generates program code (HTML, CSS, JavaScript) using a generative AI model based on the extracted text data. The input includes the extracted text data and a prompt for the generative model. The output is the generated program code.

[0151] Specific behavior:

[0152] The server generates a prompt and sets it as follows:

[0153] Given the following user-provided text, generate HTML, CSS, and JavaScript code for a rich web page.

[0154] Text data: "Extracted text goes here."

[0155] The server sends a prompt to the generative AI model (e.g., OpenAI's API).

[0156] It receives the program code returned by the generative AI model and formats it as needed.

[0157] Step 5:

[0158] The server provides the generated program code to the user, and the input includes the generated program code, and the output is transmitted to the user for display or download.

[0159] Specific behavior:

[0160] The server packages the generated HTML, CSS, and JavaScript code into an HTTP response.

[0161] The server sends an HTTP response, and the terminal receives it.

[0162] The device displays the code in the browser and allows the user to download or copy it for use.

[0163] By following these steps, users can quickly generate rich web pages without specialized coding skills.

[0164] (Application example 1)

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

[0166] Previously, for brick-and-mortar store owners to easily publish their latest promotional information and store information on a web page, specialized skills were often required, resulting in a time-consuming and labor-intensive process. Furthermore, the complex operations required made it difficult for people without technical knowledge to use. This created the challenge of making it difficult to quickly update store information online.

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

[0168] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for generating program code based on the extracted text data, means for outputting the generated program code, and means for providing the generated program code to a user via a smartphone application. This enables store owners without specialized skills to easily and quickly generate rich web pages containing promotional information and provide them to customers.

[0169] "User" means a person or entity that utilizes the system to upload document files and generate web pages.

[0170] A "document file" is a digital file format created by a user, such as a PDF or presentation file.

[0171] The "receiving means" refers to the interface and server functions that allow users to upload document files they have created to the system.

[0172] The "means for checking the format" is a function for checking that the received document file is in a specified format (PDF or presentation file).

[0173] "Means for analyzing and extracting" are algorithms and libraries for reading text data from document files and extracting the necessary information.

[0174] "Means for generating program code" refers to machine learning models and APIs for generating HTML, CSS, and JavaScript code for web pages based on extracted text data.

[0175] The "means for outputting" is a function for transmitting the generated program code to the user's terminal so that it can be displayed or saved.

[0176] A "smartphone application" is software that runs on a smartphone and allows users to upload document files and generate web pages.

[0177] The "means of providing" is a function for notifying the user of the generated program code through the smartphone application and making it available for use.

[0178] A system for implementing the present invention is for automatically generating rich web pages using document files created by users. The system comprises the following means:

[0179] 1. How to receive document files

[0180] A user uploads a PDF or presentation file they created to the app using a smartphone application. The application then sends the file from the device to the server via an HTTP request, and the server receives the request and temporarily stores the document file.

[0181] 2. Format confirmation method

[0182] The server checks whether the received document file is in PDF format or presentation file format (e.g., PPTX). Specifically, the server checks the file extension, and if it is not a supported format, it returns an error message.

[0183] 3. Analysis and Text Extraction Methods

[0184] The server selects the appropriate parsing method depending on the received file format and extracts text data from the document file: for PDF files, it uses the pdfminer library to extract text, and for presentation files, it uses the python-pptx library to extract the text of each slide.

[0185] 4. Program code generation method

[0186] The server generates program code based on the extracted text data. Specifically, it uses the OpenAI API, a generative AI model, to automatically generate HTML, CSS, and JavaScript code. This process defines the appearance and functionality of the web page based on the extracted text.

[0187] 5. Output Method

[0188] The generated program code is sent from the server to the user's smartphone application, where the user can view the generated web page and share the URL as needed.

[0189] Specific examples include the following processes:

[0190] Example 1: Creating a web page from a PDF file

[0191] A user creates a PDF file named "example.pdf" and uploads it to the system. The server receives the file and verifies that it is in PDF format. It then uses the pdfminer library to extract text data and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's smartphone application, which makes it available as a web page.

[0192] Example 2: Generating a web page from a presentation file

[0193] A user creates a presentation file named "example.pptx" and uploads it to the system. The server receives the file and verifies that it is a presentation file. It then uses the python-pptx library to extract the text from each slide and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's smartphone application, which makes it available as a web page.

[0194] Example prompt sentence:

[0195] Generate a rich web page using the following text:

[0196] Our new fall menu has arrived!

[0197] Our recommended dishes are mushroom risotto and pumpkin soup. We look forward to your visit.

[0198] This allows store owners to easily and quickly generate rich web pages containing promotional information and provide them to customers, even if they do not have specialized skills.

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

[0200] Step 1:

[0201] A user uploads a PDF or presentation file using a smartphone application. The user selects the file within the application, and the selected document file is sent to the server via the application.

[0202] Input: User-created document file (PDF or PPTX)

[0203] Output: The document file sent to the server

[0204] Step 2:

[0205] The server verifies that the received document file is in the specified format (PDF or PPTX). The server checks the file extension and returns an error message if the format is not supported.

[0206] Input: Document file sent to the server

[0207] Output: Result of format check (success or error message)

[0208] Step 3:

[0209] The server selects the appropriate parsing method depending on the format of the received document file and extracts text data from the document file. For PDF files, it uses the pdfminer library to extract text, and for presentation files, it uses the python-pptx library to extract the text of each slide.

[0210] Input: A document file that has passed the format check

[0211] Output: Extracted text data

[0212] Step 4:

[0213] The server generates web page program code based on the extracted text data. Specifically, it uses the OpenAI API, a generative AI model, to generate HTML, CSS, and JavaScript code. The server sends the text data to the API as a prompt and receives the generated code in response.

[0214] Input: Extracted text data

[0215] Output: Generated HTML, CSS, and JavaScript code

[0216] Step 5:

[0217] The server provides the generated program code to the user through a smartphone application, which receives the generated code and displays it as a web page in the user's browser.

[0218] Input: Generated HTML, CSS, and JavaScript code

[0219] Output: A web page displayed on the user's smartphone application.

[0220] This allows store owners to easily and quickly generate rich web pages containing promotional information and provide them to customers, even if they do not have specialized skills.

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

[0222] This system allows users to easily generate rich web pages using document files created by the user. This system has the unique feature of adjusting the design and content of the web page based on the content of the document file as well as the user's emotional information. The system's main functions are as follows:

[0223] 1. Receiving document files

[0224] A user creates a PDF or presentation file to represent a web page design, for example, a file called "example.pptx," and then uses the interface to upload the created file to the system.

[0225] 2. Check the file format

[0226] The server checks the extension of the received file to ensure that it is a PDF or presentation file (e.g., PPTX), allowing it to process only compatible formats.

[0227] 3. Document file analysis and text extraction

[0228] The server extracts the text data using the appropriate library depending on the file format: for PDF files, it uses the pdfminer library to extract the text, and for presentation files, it uses the python-pptx library to extract the text of each slide.

[0229] 4. Emotion Recognition by Emotion Engine

[0230] The server includes an emotion engine for recognizing emotions from the user's facial expressions and voice. This emotion engine analyzes the user's facial expressions and voice via a camera and microphone, and recognizes emotions such as joy, sadness, surprise, and anger in real time.

[0231] 5. Generating Program Code

[0232] The server uses OpenAI's API to generate HTML, CSS, and JavaScript code based on the extracted text and the user's recognized emotion. For example, if the user expresses surprise, the program can incorporate design elements and effects that match that emotion.

[0233] 6. Generated Code Output

[0234] The generated program code is sent from the server to the user's device, where it is displayed in a browser and can be downloaded or copied by the user.

[0235] For example:

[0236] Example 1: Creating a web page from a PDF file

[0237] A user creates a PDF file named "example.pdf" and uploads it to the system. The server receives the file and verifies that it is in PDF format. It then extracts the text data using the pdfminer library and generates HTML, CSS, and JavaScript code via OpenAI's API. It also uses an emotion engine to recognize the user's emotions. For example, if the user is expressing joy, it generates code with a design that matches that emotion.

[0238] Example 2: Generating a web page from a presentation file

[0239] A user creates a presentation file named "example.pptx" and uploads it to the system. The server receives the file, verifies that it is a presentation file, extracts text data using the python-pptx library, and generates HTML, CSS, and JavaScript code via OpenAI's API. The emotion engine recognizes the user's emotions and generates code with dynamic effects, for example, if the user is excited.

[0240] This concludes the "Mode for Carrying Out the Invention" of the present invention. This system not only allows users to quickly and easily create rich web pages without requiring specialized coding skills, but also allows for customization according to the user's emotions.

[0241] The processing flow will be explained below.

[0242] Step 1: Prepare a user-created PDF or presentation file.

[0243] A user creates a PDF or presentation file to represent the design of a web page, for example, a file called "example.pptx."

[0244] Step 2: Upload the prepared file to the server.

[0245] The user accesses the system, selects the file from the interface for uploading the created file, and clicks the upload button.

[0246] Step 3: The device sends the selected file to the server.

[0247] The device sends the file selected by the user to the server as an HTTP POST request, with the destination endpoint being " / upload."

[0248] Step 4: The server receives the file and stores it temporarily.

[0249] The server receives the HTTP request and saves the uploaded file (e.g., "example.pptx") in a temporary directory (e.g., " / tmp").

[0250] Step 5: The server checks the file format.

[0251] The server checks the file extension of the saved file to ensure it is a PDF or presentation file (e.g., PPTX), and generates an error message for any other file type.

[0252] Step 6: The server parses the file and extracts the text data.

[0253] The server extracts the text data using an appropriate library depending on the file format.

[0254] For PDF files, the server uses the pdfminer library to extract the text.

[0255] For presentation files, the server uses the python-pptx library to extract the text of each slide.

[0256] Step 7: The server uses the emotion engine to recognize the user's emotion.

[0257] When a user uploads a file, the camera and microphone capture the user's facial expressions and voice. The server receives this data and analyzes the user's emotions using an emotion engine. For example, if the user is smiling and having fun, that emotion is recognized.

[0258] Step 8: The server generates a program code based on the extracted text data and the recognized emotion data.

[0259] The server combines the extracted text data with the recognized emotion data and sends it to OpenAI's API to generate HTML, CSS, and JavaScript code. For example, if the user is having fun, the code will be generated to include colors and design elements that match that emotion.

[0260] Step 9: The server outputs the generated program code to the user terminal.

[0261] The server packages the generated program code in JSON format and returns it to the user's device as an HTTP response.

[0262] Step 10: The terminal displays the code received from the server.

[0263] The terminal displays the received program code on a user interface, allowing the user to download or copy the code.

[0264] Step 11: The user creates a web page using the code they received.

[0265] Users can incorporate the displayed program code into their own web projects, edit and adjust it as needed, and complete a rich web page.

[0266] These are the specific processing steps of this system, which allows users to quickly and easily create rich web pages without specialized coding skills, and also customize them to suit individual emotions.

[0267] Example 2

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

[0269] Conventional web page generation systems based on document files have difficulty automatically generating designs and content that reflect the user's intentions and emotions, forcing the user to make manual adjustments. Furthermore, they lack the appropriate text extraction and analysis processes that depend on the format and content of the document file, and the process of generating program code that reflects the results. Therefore, there is a need for a system that can solve these issues and enable users to easily generate rich web pages that reflect their emotions.

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

[0271] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for acquiring emotion data from the user's device in real time, means for generating program code based on the extracted text data and the acquired emotion data, and means for outputting the generated program code. This enables users to quickly and easily generate rich web pages that reflect the user's emotions, even if they do not have specialized coding skills.

[0272] A "document file" is a data format such as a PDF or presentation file created by a user.

[0273] "Means for receiving" refers to a mechanism such as an interface or protocol that allows the server to obtain document files created by users.

[0274] "Predetermined formats" refers to specific file formats that the system can support, specifically PDF and presentation files (e.g., PPTX).

[0275] The "verification means" is a function for verifying that the format of the document file received by the server is a predetermined format.

[0276] "Means of analysis and extraction" refers to the techniques and processes required to extract text data from document files and understand their contents.

[0277] "Emotion data" is information about emotions acquired from the user's facial expressions and voice, and includes joy, sadness, surprise, anger, and the like.

[0278] "Means for acquiring data in real time" refers to a technology that uses the user's device (camera or microphone) to instantly analyze the user's current facial expressions and voice, and collects emotional data as a result.

[0279] The "means for generating program code" is a technology that automatically creates web page generation code such as HTML, CSS, and JavaScript based on the extracted text data and acquired emotion data.

[0280] The "means for outputting" is a mechanism for transmitting the generated program code to the user's terminal so that it can be displayed on the browser or downloaded.

[0281] A "machine learning model" is an algorithm or model that learns patterns and predictions from data and performs a specific task (in this case, converting text and emotion data into program code).

[0282] This invention is a system for quickly and easily generating rich web pages using document files created by users. This system has the unique feature of adjusting the design and content of web pages based on the content of the document file as well as the user's emotional information. This system mainly uses the following hardware and software:

[0283] First, a user creates a PDF or presentation file to represent the design of a web page. For example, they create a file called "example.pptx" and upload it to the system. The user then uses an interface (such as a browser-based upload form) to upload the file.

[0284] The server receives the uploaded document file and checks its extension. If the file format is PDF, it uses the pdfminer library to extract text data. On the other hand, if the file format is a presentation file (PPTX), it uses the python-pptx library to extract the text of each slide. For example, to extract text from a PDF file, the following specific process is performed:

[0285] Parse the PDF file using PDFParser from pdfminer.six.

[0286] Use PDFPageInterpreter to extract the text content of each page.

[0287] The server also collects emotion data in real time from the user's device. The emotion data is collected through the user's camera and microphone, and analyzed by the emotion engine. The emotion engine works as follows:

[0288] Facial expression recognition: Image recognition technology is used to extract the features of the user's facial expression and classify their emotions based on this.

[0289] Speech recognition: Analyzes voice data obtained from a microphone and evaluates the tone and rate to determine emotion.

[0290] The server then uses OpenAI's API to generate HTML, CSS, and JavaScript code based on the extracted text and emotion data. For example, if the user expresses joy, the generated web page will incorporate bright colors and animation effects.

[0291] The device receives the generated HTML, CSS, and JavaScript code sent by the server and displays it in the browser, where the user can download and edit the code.

[0292] For example:

[0293] Example 1: Creating a web page from a PDF file

[0294] 1. A user creates a PDF file named "example.pdf" and uploads it to the system.

[0295] 2. The server checks the file format and extracts the text data from the PDF file using the pdfminer library.

[0296] 3. The server uses the emotion engine to recognize the user's emotion of joy.

[0297] 4. The server uses OpenAI's API to generate HTML, CSS, and JavaScript code for a brightly colored web page.

[0298] 5. The terminal will display the generated code in your browser.

[0299] Example prompt:

[0300] "If the user is expressing joy, generate a web page with text extracted from the PDF, a bright key color, and a vibrant layout."

[0301] Example 2: Generating a web page from a presentation file

[0302] 1. A user creates a presentation file named "example.pptx" and uploads it to the system.

[0303] 2. The server checks the file format and extracts the text data from the presentation file using the python-pptx library.

[0304] 3. The server uses the emotion engine to recognize the user's emotion of excitement.

[0305] 4. The server uses OpenAI's API to generate the HTML, CSS, and JavaScript code for the web page, including the dynamic effects.

[0306] 5. The terminal will display the generated code in your browser.

[0307] Example prompt:

[0308] "If your users are excited, generate a web page with the text extracted from the PPTX and incorporate dynamic design with animation effects."

[0309] This system allows users to quickly and easily generate rich web pages without specialized coding skills, and also allows them to customize them according to their emotions.

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

[0311] Step 1: Upload your document files

[0312] The user creates a PDF or presentation file (e.g., "example.pptx") and uploads the file using the system's file upload interface.

[0313] Input: User-created document file

[0314] Output: Document file uploaded to the server

[0315] Step 2: Check the file format

[0316] The server checks the file extension of the uploaded document. If the file format is not PDF or PPTX, it returns an error message to the user. For example, if the file extension is .txt, it displays the message "Unsupported file format."

[0317] Input: Uploaded document file

[0318] Output: File format check result (PDF / PPTX or error message)

[0319] Step 3: Analyze the document file and extract text

[0320] The server extracts the text using the appropriate library depending on the file format.

[0321] For PDF files: Parse the PDF file using PDFParser from pdfminer.six and extract the text content of each page with PDFPageInterpreter.

[0322] For presentation files (PPTX): Use the python-pptx library to read the PPTX file and extract the text of each slide, along with the text styles (font, size, color, etc.) within each slide.

[0323] Input: Document file (PDF or PPTX)

[0324] Output: Extracted text data

[0325] Step 4: Emotion Recognition with the Emotion Engine

[0326] The server acquires the user's emotional data in real time through the device's camera and microphone, and the emotion engine analyzes the acquired data to determine the user's emotions (joy, sadness, surprise, anger, etc.).

[0327] Facial Expression Recognition: Using image recognition technology, the feature points of the user's facial expression are analyzed to classify emotions.

[0328] Speech recognition: Analyzes voice data obtained from the microphone and determines emotions from the tone and speed of the voice.

[0329] Input: Real-time data from camera and microphone

[0330] Output: User emotion data

[0331] Step 5: Generate code for the web page

[0332] The server uses OpenAI's API to generate HTML, CSS, and JavaScript code based on the extracted text data and acquired emotion data.

[0333] Emotional design elements: For example, if the user is expressing the emotion of joy, incorporate bright colors and animated designs.

[0334] Use of generative AI models: Generate prompts based on text and emotion data, and input them into OpenAI's API to generate program code.

[0335] Input: Text data, emotion data, prompt sentence

[0336] Output: Generated HTML, CSS, and JavaScript code

[0337] Step 6: Outputting the generated code

[0338] The device receives the generated HTML, CSS, and JavaScript code sent from the server and displays it in the browser. The user can download and edit this code, allowing for final confirmation and correction of the generated web page.

[0339] Input: Generated HTML, CSS, and JavaScript code

[0340] Output: Web page displayed in browser, and downloadable program code

[0341] (Application example 2)

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

[0343] Conventional web page generation systems using document files were unable to adjust design and content to take user emotions into account, and could only provide generic designs. Furthermore, it was difficult to display promotional content that responded to customer emotions in real time, especially in brick-and-mortar stores. This led to the problem of being unable to implement effective marketing that responded to customer emotions.

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

[0345] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for generating program code based on the extracted text data and user emotion data, and means for displaying the generated program code in real time on a display device in the requesting store. This allows users to utilize emotion recognition technology to display rich web pages and promotional content in real time in physical stores in response to customer emotions.

[0346] "User" means a person who uses this system to upload document files or use generated codes.

[0347] A "Document File" is a PDF or presentation format file that contains content created by a user.

[0348] The "means for receiving" is a means for uploading a document file created by a user to the system.

[0349] "Specified format" refers to a PDF or presentation format file that the system can handle.

[0350] The "verification means" is a means for checking whether the received document file is in a predetermined format.

[0351] The "means for analyzing and extracting" is a means for analyzing text data from a document file and extracting necessary information.

[0352] "Emotion data" refers to emotional information obtained by analyzing the user's facial expressions and voice.

[0353] The "means for generating program code" refers to a means for generating code such as HTML, CSS, or JavaScript based on the extracted text data and user emotion data.

[0354] The "display device in the requesting store" refers to a video display device such as a display, screen, or smart glasses installed in a physical store.

[0355] The "means for displaying in real time" refers to a means for immediately displaying the generated program code on a display device in the requesting store.

[0356] A "generative AI model" is an AI technology used to generate program code from text data and emotion data using machine learning techniques.

[0357] This invention relates to a system that uses document files created by users to display rich web pages and promotional content in real time on display devices in physical stores. This system has the unique feature of adjusting the design and content based on the content of the document file as well as the user's emotional data. The configuration and operation of this system are described in detail below.

[0358] The system consists of the following main steps:

[0359] 1. Receiving document files

[0360] A user creates a PDF or presentation file (PPTX) to represent the design of a web page or promotional content, and uploads it to the system. For example, a file named "promotion.pptx" is created. The user then uses the interface to upload the created file to the system.

[0361] 2. Check the file format

[0362] The server checks the extension of the received file to ensure it is a supported format (PDF or presentation file), allowing for proper control over the file formats that are processed.

[0363] 3. Document file analysis and text extraction

[0364] The server extracts the text data using the appropriate library depending on the file format (pdfminer for PDFs, python-pptx for presentation files).

[0365] 4. Emotion Data Recognition

[0366] The server includes an emotion engine that analyzes the user's facial expressions and voice via a camera and microphone to recognize emotion data. This emotion engine recognizes the user's emotions, such as joy, sadness, surprise, and anger, in real time.

[0367] 5. Generating Program Code

[0368] The server uses a generative AI model (e.g., OpenAI's API) to generate HTML, CSS, and JavaScript code based on the extracted text data and the user's recognized emotion data, dynamically adjusting design elements and effects according to the emotion data.

[0369] 6. Output and View the Generated Code

[0370] The generated program code is sent in real time from the server to the display device in the requesting store, which then displays a rich web page or promotional content that reflects the user's emotions.

[0371] As a concrete example, consider a case where a store salesperson creates a presentation for a new product launch in PPTX format and uploads it to the system. The system extracts text from the presentation file and recognizes the emotions of customers visiting the physical store by reading their facial expressions via a camera. For example, if a customer expresses surprise, the system generates a web page with dynamic and vivid effects, which is displayed in real time on in-store displays and on the salesperson's smart glasses. This process allows the store to implement effective promotions that are in line with customer emotions.

[0372] Prompt Sentence Examples

[0373] Generate a HTML / CSS / JS code for a web page with the following content:

[0374] Welcome to the new product launch event! Today's menu is as follows: 1. New product introduction 2. Special promotion 3. Q&A. Make it vibrant and suited to surprise emotion.

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

[0376] Step 1:

[0377] Receive document files created by users

[0378] How it works: A user uploads a PDF or presentation file (PPTX) to the system.

[0379] Input: A user-created document file.

[0380] Output: The document file is saved on the server.

[0381] Step 2:

[0382] Checking the format of the received document file

[0383] What happens: The server checks the file extension and sees if it is in a supported format (PDF or PPTX).

[0384] Input: A document file stored on the server.

[0385] Output: Verification that the file is in a supported format.

[0386] Step 3:

[0387] Analyze and extract text data from document files

[0388] How it works: The server extracts text from PDF files using the pdfminer library, or from PPTX files using the python-pptx library.

[0389] Input: Authenticated document file.

[0390] Output: The extracted text data.

[0391] Step 4:

[0392] Recognizing Emotional Data

[0393] How it works: The server analyzes the user's facial expressions and voice through the camera and microphone, and uses an emotion engine to recognize emotional data.

[0394] Input: User facial and voice data captured by camera and microphone.

[0395] Output: Recognized user emotion data.

[0396] Step 5:

[0397] Generate program code

[0398] How it works: The server uses a generative AI model (e.g., OpenAI's API) to generate HTML, CSS, and JavaScript code based on the extracted text and emotion data.

[0399] Input: Extracted text data and recognized emotion data.

[0400] Output: Generated HTML, CSS, and JavaScript code.

[0401] Step 6:

[0402] Print the generated code

[0403] Operation: The generated program code is sent in real time from the server to the display device in the requesting store.

[0404] Input: Generated HTML, CSS, and JavaScript code.

[0405] Output: Rich web pages and promotional content displayed on display devices within the requested store.

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

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

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

[0409] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0422] This system allows users to easily generate rich web pages using document files they have created. The system has the following main functions:

[0423] 1. Receiving document files

[0424] The user uploads the PDF or presentation file they created to the system. At this time, the terminal selects the file and sends it to the server. The server receives the HTTP request and temporarily stores the file.

[0425] 2. Check the format of the document file

[0426] The server checks whether the received file is a PDF or presentation file (e.g., PPTX). This allows it to process only compatible formats. The server checks the file extension and returns an error message for files that are not in the required format.

[0427] 3. Document file analysis and text extraction

[0428] The server selects the appropriate parsing method depending on the received file format and extracts text data from the document file. For PDF files, it uses the pdfminer library to extract text. For presentation files, it uses the python-pptx library to extract the text of each slide.

[0429] 4. Generate program code

[0430] The server generates program code based on the extracted text data. Specifically, it uses OpenAI's API to automatically generate HTML, CSS, and JavaScript code. The generated code is essential for providing the appearance and functionality of the web page.

[0431] 5. Generated Code Output

[0432] The generated program code is sent from the server to the user's device, where it is displayed in a browser and can be downloaded or copied by the user.

[0433] The following is a concrete example of this system:

[0434] Example 1: Creating a web page from a PDF file

[0435] A user creates a PDF file named "example.pdf" and uploads it to the system. The server receives the file and verifies that it is in PDF format. It then uses the pdfminer library to extract the text data and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's device, where it can be used as a web page.

[0436] Example 2: Generating a web page from a presentation file

[0437] A user creates a presentation file named "example.pptx" and uploads it to the system. The server receives the file and verifies that it is a presentation file. It then uses the python-pptx library to extract the text from each slide and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's device, where it can be used as a web page.

[0438] This concludes the description of the present invention. The system allows users to quickly and easily create rich web pages without specialized coding skills.

[0439] The processing flow will be explained below.

[0440] Step 1: Prepare a user-created PDF or presentation file.

[0441] A user creates a PDF or presentation file to represent the design of a web page, for example, a file called "example.pptx."

[0442] Step 2: Upload the prepared file to the server.

[0443] The user accesses the system, selects the file from the interface for uploading the created file, and clicks the upload button.

[0444] Step 3: The device sends the selected file to the server.

[0445] The device sends the file selected by the user to the server as an HTTP POST request, with the destination endpoint being " / upload."

[0446] Step 4: The server receives the file and stores it temporarily.

[0447] The server receives the HTTP request and saves the uploaded file (e.g., "example.pptx") in a temporary directory (e.g., " / tmp").

[0448] Step 5: The server checks the file format.

[0449] The server checks the file extension of the saved file to ensure it is a PDF or presentation file (e.g., PPTX), and generates an error message for any other file type.

[0450] Step 6: The server parses the file and extracts the text data.

[0451] The server extracts the text data using an appropriate library depending on the file format.

[0452] For PDF files, the server uses the pdfminer library to extract the text.

[0453] For presentation files, the server uses the python-pptx library to extract the text of each slide.

[0454] Step 7: The server generates program code based on the extracted text data.

[0455] The server sends the extracted text data to OpenAI's API and generates program code (HTML, CSS, JavaScript) by specifying a prompt such as "Please generate HTML and CSS code."

[0456] Step 8: The server outputs the generated program code to the user terminal.

[0457] The server packages the generated program code in JSON format and returns it to the user's device as an HTTP response.

[0458] Step 9: The terminal displays the code received from the server.

[0459] The terminal displays the received program code on a user interface, allowing the user to download or copy the code.

[0460] Step 10: The user creates a web page using the code they received.

[0461] Users can incorporate the displayed program code into their own web projects, edit and adjust it as needed, and complete a rich web page.

[0462] In this way, the system helps users automatically generate rich web pages from existing document files without requiring specialized knowledge.

[0463] Example 1

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

[0465] There is a demand for a system that allows users to quickly and easily generate rich web pages from document files they have created without having specialized coding skills. Conventional methods require specialized knowledge and time to extract text data from document files and convert it into web page code. The challenge is to solve this problem and provide a method that allows users to easily generate web pages.

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

[0467] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for using a generative model to generate program code based on the extracted text data, and means for outputting the generated program code, thereby enabling users to quickly and easily create rich web pages without specialized coding skills.

[0468] "User" refers to any individual or entity that intends to use the System to generate a Web page from a document file.

[0469] "Document File" refers to a PDF file or electronic slideshow file (presentation file) created by a User and uploaded to the System.

[0470] "Means for receiving" refers to the method or process by which the server receives the document file sent from the user's terminal.

[0471] "Means for verifying" refers to the method or process for verifying that the format of the document file received by the server is in the specified format (PDF or electronic slideshow file).

[0472] "Means for analyzing and extracting" refers to the method or process by which the server analyzes the contents of the document file and extracts text data therefrom.

[0473] "Means of using a generative model" refers to the method or process for generating program code (HTML, CSS, JavaScript) using a generative AI model based on extracted text data.

[0474] "Means for outputting" refers to a method or process for providing the generated program code to the user.

[0475] The "predetermined format" refers to a file format that the system can handle, specifically a PDF format or an electronic slideshow file format (presentation file format).

[0476] A "generative model" refers to a machine learning or artificial intelligence model used to generate program code based on text data.

[0477] A "prompt statement" is a document or instruction that is input to a generative model and is used to specify the content and format of the program code to be generated.

[0478] This invention relates to a system for generating rich web pages from document files created by users. The system provides a series of processes that allow users to upload document files and automatically generate code for web pages from those files.

[0479] System Configuration

[0480] Hardware

[0481] The system consists of the following hardware:

[0482] 1. Server: Receives files, analyzes them, inputs them into the generative model, generates program code, and outputs it.

[0483] 2. Terminal: The user uploads a document file and receives and displays the generated web page code.

[0484] software

[0485] The system consists of the following software:

[0486] 1. File receiving module: Receives document files uploaded by users.

[0487] 2. Format Verification Module: Verifies that the received file is in the required format (PDF or electronic slideshow file).

[0488] 3. Text Extraction Module: Analyzes the content of document files and extracts text data. Specifically, it uses the pdfminer library for PDF files and the python-pptx library for presentation files.

[0489] 4. Code generation module: Generates HTML, CSS, and JavaScript program code based on the extracted text data using a generative AI model. The generative model uses OpenAI's API.

[0490] 5. Code output module: Provides the generated program code to the user.

[0491] Example of operation

[0492] Example 1: Creating a web page from a PDF file

[0493] 1. A user creates a PDF file called "example.pdf" and uploads it to the system via the terminal.

[0494] 2. The server uses the file receiving module to receive the file and the format confirmation module to confirm that it is in PDF format.

[0495] 3. The server uses the pdfminer library to extract text data from the PDF file.

[0496] 4. Based on the extracted text data, generate a prompt sentence like the following and input it into the generative model:

[0497] Given the following user-provided text, generate HTML, CSS, and JavaScript code for a rich web page.

[0498] Text data: "Extracted text goes here."

[0499] 5. The generative AI model generates HTML, CSS, and JavaScript code based on the input prompt.

[0500] 6. The server receives the generated code and sends it to the terminal using the code output module.

[0501] 7. The user receives the web page code generated on their device and can view it in their browser or download it for use.

[0502] Example 2: Generating a web page from a presentation file

[0503] 1. A user creates a presentation file called "example.pptx" and uploads it to the system through the terminal.

[0504] 2. The server receives the file using the file receiving module and verifies that it is in presentation file format using the format verification module.

[0505] 3. The server uses the python-pptx library to extract text data from each slide in the presentation file.

[0506] 4. Based on the extracted text data, generate a prompt sentence like the following and input it into the generative model:

[0507] Given the following user-provided text, generate HTML, CSS, and JavaScript code for a rich web page.

[0508] Text data: "Extracted text goes here."

[0509] 5. The generative AI model generates HTML, CSS, and JavaScript code based on the input prompt.

[0510] 6. The server receives the generated code and sends it to the terminal using the code output module.

[0511] 7. The user receives the web page code generated on their device and can view it in their browser or download it for use.

[0512] The system allows users to quickly and easily create rich web pages without specialized coding skills.

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

[0514] Step 1:

[0515] The user selects a document file and uploads it to the system. The input includes the PDF or presentation file selected by the user. The output is the selected file sent to the server.

[0516] Specific behavior:

[0517] The user clicks the file selection button and a file selection dialog appears.

[0518] The user selects a document file (e.g., "example.pdf") and clicks the "Open" button.

[0519] The device sends the selected file to the server via an HTTP POST request.

[0520] Step 2:

[0521] The server checks the format of the document file received. The input includes the file extension. The output is a determination of whether the format is a specified format (PDF or presentation file).

[0522] Specific behavior:

[0523] Extract the extension of the file received by the server.

[0524] Check that the extracted file extension is ".pdf" or ".pptx".

[0525] If it is not in a supported format, the server generates an error message and returns it to the user.

[0526] Step 3:

[0527] The server analyzes the contents of document files to extract text data. The inputs include PDF or presentation files. The output is the extracted text data.

[0528] Specific behavior:

[0529] The server calls the appropriate library depending on the file format.

[0530] For PDF files, it uses the pdfminer library to extract text from each page.

[0531] For presentation files, we use the python-pptx library to extract the text from each slide.

[0532] The extracted text data is stored in memory.

[0533] Step 4:

[0534] The server generates program code (HTML, CSS, JavaScript) using a generative AI model based on the extracted text data. The input includes the extracted text data and a prompt for the generative model. The output is the generated program code.

[0535] Specific behavior:

[0536] The server generates a prompt and sets it as follows:

[0537] Given the following user-provided text, generate HTML, CSS, and JavaScript code for a rich web page.

[0538] Text data: "Extracted text goes here."

[0539] The server sends a prompt to the generative AI model (e.g., OpenAI's API).

[0540] It receives the program code returned by the generative AI model and formats it as needed.

[0541] Step 5:

[0542] The server provides the generated program code to the user, and the input includes the generated program code, and the output is transmitted to the user for display or download.

[0543] Specific behavior:

[0544] The server packages the generated HTML, CSS, and JavaScript code into an HTTP response.

[0545] The server sends an HTTP response, and the terminal receives it.

[0546] The device displays the code in the browser and allows the user to download or copy it for use.

[0547] By following these steps, users can quickly generate rich web pages without specialized coding skills.

[0548] (Application example 1)

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

[0550] Previously, for brick-and-mortar store owners to easily publish their latest promotional information and store information on a web page, specialized skills were often required, resulting in a time-consuming and labor-intensive process. Furthermore, the complex operations required made it difficult for people without technical knowledge to use. This created the challenge of making it difficult to quickly update store information online.

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

[0552] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for generating program code based on the extracted text data, means for outputting the generated program code, and means for providing the generated program code to a user via a smartphone application. This enables store owners without specialized skills to easily and quickly generate rich web pages containing promotional information and provide them to customers.

[0553] "User" means a person or entity that utilizes the system to upload document files and generate web pages.

[0554] A "document file" is a digital file format created by a user, such as a PDF or presentation file.

[0555] The "receiving means" refers to the interface and server functions that allow users to upload document files they have created to the system.

[0556] The "means for checking the format" is a function for checking that the received document file is in a specified format (PDF or presentation file).

[0557] "Means for analyzing and extracting" are algorithms and libraries for reading text data from document files and extracting the necessary information.

[0558] "Means for generating program code" refers to machine learning models and APIs for generating HTML, CSS, and JavaScript code for web pages based on extracted text data.

[0559] The "means for outputting" is a function for transmitting the generated program code to the user's terminal so that it can be displayed or saved.

[0560] A "smartphone application" is software that runs on a smartphone and allows users to upload document files and generate web pages.

[0561] The "means of providing" is a function for notifying the user of the generated program code through the smartphone application and making it available for use.

[0562] A system for implementing the present invention is for automatically generating rich web pages using document files created by users. The system comprises the following means:

[0563] 1. How to receive document files

[0564] A user uploads a PDF or presentation file they created to the app using a smartphone application. The application then sends the file from the device to the server via an HTTP request, and the server receives the request and temporarily stores the document file.

[0565] 2. Format confirmation method

[0566] The server checks whether the received document file is in PDF format or presentation file format (e.g., PPTX). Specifically, the server checks the file extension, and if it is not a supported format, it returns an error message.

[0567] 3. Analysis and Text Extraction Methods

[0568] The server selects the appropriate parsing method depending on the received file format and extracts text data from the document file: for PDF files, it uses the pdfminer library to extract text, and for presentation files, it uses the python-pptx library to extract the text of each slide.

[0569] 4. Program code generation method

[0570] The server generates program code based on the extracted text data. Specifically, it uses the OpenAI API, a generative AI model, to automatically generate HTML, CSS, and JavaScript code. This process defines the appearance and functionality of the web page based on the extracted text.

[0571] 5. Output Method

[0572] The generated program code is sent from the server to the user's smartphone application, where the user can view the generated web page and share the URL as needed.

[0573] Specific examples include the following processes:

[0574] Example 1: Creating a web page from a PDF file

[0575] A user creates a PDF file named "example.pdf" and uploads it to the system. The server receives the file and verifies that it is in PDF format. It then uses the pdfminer library to extract text data and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's smartphone application, which makes it available as a web page.

[0576] Example 2: Generating a web page from a presentation file

[0577] A user creates a presentation file named "example.pptx" and uploads it to the system. The server receives the file and verifies that it is a presentation file. It then uses the python-pptx library to extract the text from each slide and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's smartphone application, which makes it available as a web page.

[0578] Example prompt sentence:

[0579] Generate a rich web page using the following text:

[0580] Our new fall menu has arrived!

[0581] Our recommended dishes are mushroom risotto and pumpkin soup. We look forward to your visit.

[0582] This allows store owners to easily and quickly generate rich web pages containing promotional information and provide them to customers, even if they do not have specialized skills.

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

[0584] Step 1:

[0585] A user uploads a PDF or presentation file using a smartphone application. The user selects the file within the application, and the selected document file is sent to the server via the application.

[0586] Input: User-created document file (PDF or PPTX)

[0587] Output: The document file sent to the server

[0588] Step 2:

[0589] The server verifies that the received document file is in the specified format (PDF or PPTX). The server checks the file extension and returns an error message if the format is not supported.

[0590] Input: Document file sent to the server

[0591] Output: Result of format check (success or error message)

[0592] Step 3:

[0593] The server selects the appropriate parsing method depending on the format of the received document file and extracts text data from the document file. For PDF files, it uses the pdfminer library to extract text, and for presentation files, it uses the python-pptx library to extract the text of each slide.

[0594] Input: A document file that has passed the format check

[0595] Output: Extracted text data

[0596] Step 4:

[0597] The server generates web page program code based on the extracted text data. Specifically, it uses the OpenAI API, a generative AI model, to generate HTML, CSS, and JavaScript code. The server sends the text data to the API as a prompt and receives the generated code in response.

[0598] Input: Extracted text data

[0599] Output: Generated HTML, CSS, and JavaScript code

[0600] Step 5:

[0601] The server provides the generated program code to the user through a smartphone application, which receives the generated code and displays it as a web page in the user's browser.

[0602] Input: Generated HTML, CSS, and JavaScript code

[0603] Output: A web page displayed on the user's smartphone application.

[0604] This allows store owners to easily and quickly generate rich web pages containing promotional information and provide them to customers, even if they do not have specialized skills.

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

[0606] This system allows users to easily generate rich web pages using document files created by the user. This system has the unique feature of adjusting the design and content of the web page based on the content of the document file as well as the user's emotional information. The system's main functions are as follows:

[0607] 1. Receiving document files

[0608] A user creates a PDF or presentation file to represent a web page design, for example, a file called "example.pptx," and then uses the interface to upload the created file to the system.

[0609] 2. Check the file format

[0610] The server checks the extension of the received file to ensure that it is a PDF or presentation file (e.g., PPTX), allowing it to process only compatible formats.

[0611] 3. Document file analysis and text extraction

[0612] The server extracts the text data using the appropriate library depending on the file format: for PDF files, it uses the pdfminer library to extract the text, and for presentation files, it uses the python-pptx library to extract the text of each slide.

[0613] 4. Emotion Recognition by Emotion Engine

[0614] The server includes an emotion engine for recognizing emotions from the user's facial expressions and voice. This emotion engine analyzes the user's facial expressions and voice via a camera and microphone, and recognizes emotions such as joy, sadness, surprise, and anger in real time.

[0615] 5. Generating Program Code

[0616] The server uses OpenAI's API to generate HTML, CSS, and JavaScript code based on the extracted text and the user's recognized emotion. For example, if the user expresses surprise, the program can incorporate design elements and effects that match that emotion.

[0617] 6. Generated Code Output

[0618] The generated program code is sent from the server to the user's device, where it is displayed in a browser and can be downloaded or copied by the user.

[0619] For example:

[0620] Example 1: Creating a web page from a PDF file

[0621] A user creates a PDF file named "example.pdf" and uploads it to the system. The server receives the file and verifies that it is in PDF format. It then extracts the text data using the pdfminer library and generates HTML, CSS, and JavaScript code via OpenAI's API. It also uses an emotion engine to recognize the user's emotions. For example, if the user is expressing joy, it generates code with a design that matches that emotion.

[0622] Example 2: Generating a web page from a presentation file

[0623] A user creates a presentation file named "example.pptx" and uploads it to the system. The server receives the file, verifies that it is a presentation file, extracts text data using the python-pptx library, and generates HTML, CSS, and JavaScript code via OpenAI's API. The emotion engine recognizes the user's emotions and generates code with dynamic effects, for example, if the user is excited.

[0624] This concludes the "Mode for Carrying Out the Invention" of the present invention. This system not only allows users to quickly and easily create rich web pages without requiring specialized coding skills, but also allows for customization according to the user's emotions.

[0625] The processing flow will be explained below.

[0626] Step 1: Prepare a user-created PDF or presentation file.

[0627] A user creates a PDF or presentation file to represent the design of a web page, for example, a file called "example.pptx."

[0628] Step 2: Upload the prepared file to the server.

[0629] The user accesses the system, selects the file from the interface for uploading the created file, and clicks the upload button.

[0630] Step 3: The device sends the selected file to the server.

[0631] The device sends the file selected by the user to the server as an HTTP POST request, with the destination endpoint being " / upload."

[0632] Step 4: The server receives the file and stores it temporarily.

[0633] The server receives the HTTP request and saves the uploaded file (e.g., "example.pptx") in a temporary directory (e.g., " / tmp").

[0634] Step 5: The server checks the file format.

[0635] The server checks the file extension of the saved file to ensure it is a PDF or presentation file (e.g., PPTX), and generates an error message for any other file type.

[0636] Step 6: The server parses the file and extracts the text data.

[0637] The server extracts the text data using an appropriate library depending on the file format.

[0638] For PDF files, the server uses the pdfminer library to extract the text.

[0639] For presentation files, the server uses the python-pptx library to extract the text of each slide.

[0640] Step 7: The server uses the emotion engine to recognize the user's emotion.

[0641] When a user uploads a file, the camera and microphone capture the user's facial expressions and voice. The server receives this data and analyzes the user's emotions using an emotion engine. For example, if the user is smiling and having fun, that emotion is recognized.

[0642] Step 8: The server generates a program code based on the extracted text data and the recognized emotion data.

[0643] The server combines the extracted text data with the recognized emotion data and sends it to OpenAI's API to generate HTML, CSS, and JavaScript code. For example, if the user is having fun, the code will be generated to include colors and design elements that match that emotion.

[0644] Step 9: The server outputs the generated program code to the user terminal.

[0645] The server packages the generated program code in JSON format and returns it to the user's device as an HTTP response.

[0646] Step 10: The terminal displays the code received from the server.

[0647] The terminal displays the received program code on a user interface, allowing the user to download or copy the code.

[0648] Step 11: The user creates a web page using the code they received.

[0649] Users can incorporate the displayed program code into their own web projects, edit and adjust it as needed, and complete a rich web page.

[0650] These are the specific processing steps of this system, which allows users to quickly and easily create rich web pages without specialized coding skills, and also customize them to suit individual emotions.

[0651] Example 2

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

[0653] Conventional web page generation systems based on document files have difficulty automatically generating designs and content that reflect the user's intentions and emotions, forcing the user to make manual adjustments. Furthermore, they lack the appropriate text extraction and analysis processes that depend on the format and content of the document file, and the process of generating program code that reflects the results. Therefore, there is a need for a system that can solve these issues and enable users to easily generate rich web pages that reflect their emotions.

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

[0655] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for acquiring emotion data from the user's device in real time, means for generating program code based on the extracted text data and the acquired emotion data, and means for outputting the generated program code. This enables users to quickly and easily generate rich web pages that reflect the user's emotions, even if they do not have specialized coding skills.

[0656] A "document file" is a data format such as a PDF or presentation file created by a user.

[0657] "Means for receiving" refers to a mechanism such as an interface or protocol that allows the server to obtain document files created by users.

[0658] "Predetermined formats" refers to specific file formats that the system can support, specifically PDF and presentation files (e.g., PPTX).

[0659] The "verification means" is a function for verifying that the format of the document file received by the server is a predetermined format.

[0660] "Means of analysis and extraction" refers to the techniques and processes required to extract text data from document files and understand their contents.

[0661] "Emotion data" is information about emotions acquired from the user's facial expressions and voice, and includes joy, sadness, surprise, anger, and the like.

[0662] "Means for acquiring data in real time" refers to a technology that uses the user's device (camera or microphone) to instantly analyze the user's current facial expressions and voice, and collects emotional data as a result.

[0663] The "means for generating program code" is a technology that automatically creates web page generation code such as HTML, CSS, and JavaScript based on the extracted text data and acquired emotion data.

[0664] The "means for outputting" is a mechanism for transmitting the generated program code to the user's terminal so that it can be displayed on the browser or downloaded.

[0665] A "machine learning model" is an algorithm or model that learns patterns and predictions from data and performs a specific task (in this case, converting text and emotion data into program code).

[0666] This invention is a system for quickly and easily generating rich web pages using document files created by users. This system has the unique feature of adjusting the design and content of web pages based on the content of the document file as well as the user's emotional information. This system mainly uses the following hardware and software:

[0667] First, a user creates a PDF or presentation file to represent the design of a web page. For example, they create a file called "example.pptx" and upload it to the system. The user then uses an interface (such as a browser-based upload form) to upload the file.

[0668] The server receives the uploaded document file and checks its extension. If the file format is PDF, it uses the pdfminer library to extract text data. On the other hand, if the file format is a presentation file (PPTX), it uses the python-pptx library to extract the text of each slide. For example, to extract text from a PDF file, the following specific process is performed:

[0669] Parse the PDF file using PDFParser from pdfminer.six.

[0670] Use PDFPageInterpreter to extract the text content of each page.

[0671] The server also collects emotion data in real time from the user's device. The emotion data is collected through the user's camera and microphone, and analyzed by the emotion engine. The emotion engine works as follows:

[0672] Facial expression recognition: Image recognition technology is used to extract the features of the user's facial expression and classify their emotions based on this.

[0673] Speech recognition: Analyzes voice data obtained from a microphone and evaluates the tone and rate to determine emotion.

[0674] The server then uses OpenAI's API to generate HTML, CSS, and JavaScript code based on the extracted text and emotion data. For example, if the user expresses joy, the generated web page will incorporate bright colors and animation effects.

[0675] The device receives the generated HTML, CSS, and JavaScript code sent by the server and displays it in the browser, where the user can download and edit the code.

[0676] For example:

[0677] Example 1: Creating a web page from a PDF file

[0678] 1. A user creates a PDF file named "example.pdf" and uploads it to the system.

[0679] 2. The server checks the file format and extracts the text data from the PDF file using the pdfminer library.

[0680] 3. The server uses the emotion engine to recognize the user's emotion of joy.

[0681] 4. The server uses OpenAI's API to generate HTML, CSS, and JavaScript code for a brightly colored web page.

[0682] 5. The terminal will display the generated code in your browser.

[0683] Example prompt:

[0684] "If the user is expressing joy, generate a web page with text extracted from the PDF, brighten the key color, and liven up the layout."

[0685] Example 2: Generating a web page from a presentation file

[0686] 1. A user creates a presentation file named "example.pptx" and uploads it to the system.

[0687] 2. The server checks the file format and extracts the text data from the presentation file using the python-pptx library.

[0688] 3. The server uses the emotion engine to recognize the user's emotion of excitement.

[0689] 4. The server uses OpenAI's API to generate the HTML, CSS, and JavaScript code for the web page, including the dynamic effects.

[0690] 5. The terminal will display the generated code in your browser.

[0691] Example prompt:

[0692] "If your users are excited, generate a web page with the text extracted from the PPTX and incorporate dynamic design with animation effects."

[0693] This system allows users to quickly and easily generate rich web pages without specialized coding skills, and also allows them to customize them according to their emotions.

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

[0695] Step 1: Upload your document files

[0696] The user creates a PDF or presentation file (e.g., "example.pptx") and uploads the file using the system's file upload interface.

[0697] Input: User-created document file

[0698] Output: Document file uploaded to the server

[0699] Step 2: Check the file format

[0700] The server checks the file extension of the uploaded document. If the file format is not PDF or PPTX, it returns an error message to the user. For example, if the file extension is .txt, it displays the message "Unsupported file format."

[0701] Input: Uploaded document file

[0702] Output: File format check result (PDF / PPTX or error message)

[0703] Step 3: Analyze the document file and extract text

[0704] The server extracts the text using the appropriate library depending on the file format.

[0705] For PDF files: Parse the PDF file using PDFParser from pdfminer.six and extract the text content of each page with PDFPageInterpreter.

[0706] For presentation files (PPTX): Use the python-pptx library to read the PPTX file and extract the text of each slide, along with the text styles (font, size, color, etc.) within each slide.

[0707] Input: Document file (PDF or PPTX)

[0708] Output: Extracted text data

[0709] Step 4: Emotion Recognition with the Emotion Engine

[0710] The server acquires the user's emotional data in real time through the device's camera and microphone, and the emotion engine analyzes the acquired data to determine the user's emotions (joy, sadness, surprise, anger, etc.).

[0711] Facial Expression Recognition: Using image recognition technology, the feature points of the user's facial expression are analyzed to classify emotions.

[0712] Speech recognition: Analyzes voice data obtained from the microphone and determines emotions from the tone and speed of the voice.

[0713] Input: Real-time data from camera and microphone

[0714] Output: User emotion data

[0715] Step 5: Generate code for the web page

[0716] The server uses OpenAI's API to generate HTML, CSS, and JavaScript code based on the extracted text data and acquired emotion data.

[0717] Emotional design elements: For example, if the user is expressing the emotion of joy, incorporate bright colors and animated designs.

[0718] Use of generative AI models: Generate prompts based on text and emotion data, and input them into OpenAI's API to generate program code.

[0719] Input: Text data, emotion data, prompt sentence

[0720] Output: Generated HTML, CSS, and JavaScript code

[0721] Step 6: Outputting the generated code

[0722] The device receives the generated HTML, CSS, and JavaScript code sent from the server and displays it in the browser. The user can download and edit this code, allowing for final confirmation and correction of the generated web page.

[0723] Input: Generated HTML, CSS, and JavaScript code

[0724] Output: Web page displayed in browser, and downloadable program code

[0725] (Application example 2)

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

[0727] Conventional web page generation systems using document files were unable to adjust design and content to take user emotions into account, and could only provide generic designs. Furthermore, it was difficult to display promotional content that responded to customer emotions in real time, especially in brick-and-mortar stores. This led to the problem of being unable to implement effective marketing that responded to customer emotions.

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

[0729] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for generating program code based on the extracted text data and user emotion data, and means for displaying the generated program code in real time on a display device in the requesting store. This allows users to utilize emotion recognition technology to display rich web pages and promotional content in real time in physical stores in response to customer emotions.

[0730] "User" means a person who uses this system to upload document files or use generated codes.

[0731] A "Document File" is a PDF or presentation format file that contains content created by a user.

[0732] The "means for receiving" is a means for uploading a document file created by a user to the system.

[0733] "Specified format" refers to a PDF or presentation format file that the system can handle.

[0734] The "verification means" is a means for checking whether the received document file is in a predetermined format.

[0735] The "means for analyzing and extracting" is a means for analyzing text data from a document file and extracting necessary information.

[0736] "Emotion data" refers to emotional information obtained by analyzing the user's facial expressions and voice.

[0737] The "means for generating program code" refers to a means for generating code such as HTML, CSS, or JavaScript based on the extracted text data and user emotion data.

[0738] The "display device in the requesting store" refers to a video display device such as a display, screen, or smart glasses installed in a physical store.

[0739] The "means for displaying in real time" refers to a means for immediately displaying the generated program code on a display device in the requesting store.

[0740] A "generative AI model" is an AI technology used to generate program code from text data and emotion data using machine learning techniques.

[0741] This invention relates to a system that uses document files created by users to display rich web pages and promotional content in real time on display devices in physical stores. This system has the unique feature of adjusting the design and content based on the content of the document file as well as the user's emotional data. The configuration and operation of this system are described in detail below.

[0742] The system consists of the following main steps:

[0743] 1. Receiving document files

[0744] A user creates a PDF or presentation file (PPTX) to represent the design of a web page or promotional content, and uploads it to the system. For example, a file named "promotion.pptx" is created. The user then uses the interface to upload the created file to the system.

[0745] 2. Check the file format

[0746] The server checks the extension of the received file to ensure it is a supported format (PDF or presentation file), allowing for proper control over the file formats that are processed.

[0747] 3. Document file analysis and text extraction

[0748] The server extracts the text data using the appropriate library depending on the file format (pdfminer for PDFs, python-pptx for presentation files).

[0749] 4. Emotion Data Recognition

[0750] The server includes an emotion engine that analyzes the user's facial expressions and voice via a camera and microphone to recognize emotion data. This emotion engine recognizes the user's emotions, such as joy, sadness, surprise, and anger, in real time.

[0751] 5. Generating Program Code

[0752] The server uses a generative AI model (e.g., OpenAI's API) to generate HTML, CSS, and JavaScript code based on the extracted text data and the user's recognized emotion data, dynamically adjusting design elements and effects according to the emotion data.

[0753] 6. Output and View the Generated Code

[0754] The generated program code is sent in real time from the server to the display device in the requesting store, which then displays a rich web page or promotional content that reflects the user's emotions.

[0755] As a concrete example, consider a case where a store salesperson creates a presentation for a new product launch in PPTX format and uploads it to the system. The system extracts text from the presentation file and recognizes the emotions of customers visiting the physical store by reading their facial expressions via a camera. For example, if a customer expresses surprise, the system generates a web page with dynamic and vivid effects, which is displayed in real time on in-store displays and on the salesperson's smart glasses. This process allows the store to implement effective promotions that are in line with customer emotions.

[0756] Prompt Sentence Examples

[0757] Generate a HTML / CSS / JS code for a web page with the following content:

[0758] Welcome to the new product launch event! Today's menu is as follows: 1. New product introduction 2. Special promotion 3. Q&A. Make it vibrant and suited to surprise emotion.

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

[0760] Step 1:

[0761] Receive document files created by users

[0762] How it works: A user uploads a PDF or presentation file (PPTX) to the system.

[0763] Input: A user-created document file.

[0764] Output: The document file is saved on the server.

[0765] Step 2:

[0766] Checking the format of the received document file

[0767] What happens: The server checks the file extension and sees if it is in a supported format (PDF or PPTX).

[0768] Input: A document file stored on the server.

[0769] Output: Verification that the file is in a supported format.

[0770] Step 3:

[0771] Analyze and extract text data from document files

[0772] How it works: The server extracts text from PDF files using the pdfminer library, or from PPTX files using the python-pptx library.

[0773] Input: Authenticated document file.

[0774] Output: The extracted text data.

[0775] Step 4:

[0776] Recognizing Emotional Data

[0777] How it works: The server analyzes the user's facial expressions and voice through the camera and microphone, and uses an emotion engine to recognize emotional data.

[0778] Input: User facial and voice data captured by camera and microphone.

[0779] Output: Recognized user emotion data.

[0780] Step 5:

[0781] Generate program code

[0782] How it works: The server uses a generative AI model (e.g., OpenAI's API) to generate HTML, CSS, and JavaScript code based on the extracted text and emotion data.

[0783] Input: Extracted text data and recognized emotion data.

[0784] Output: Generated HTML, CSS, and JavaScript code.

[0785] Step 6:

[0786] Print the generated code

[0787] Operation: The generated program code is sent in real time from the server to the display device in the requesting store.

[0788] Input: Generated HTML, CSS, and JavaScript code.

[0789] Output: Rich web pages and promotional content displayed on display devices within the requested store.

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

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

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

[0793] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0806] This system allows users to easily generate rich web pages using document files they have created. The system has the following main functions:

[0807] 1. Receiving document files

[0808] The user uploads the PDF or presentation file they created to the system. At this time, the terminal selects the file and sends it to the server. The server receives the HTTP request and temporarily stores the file.

[0809] 2. Check the format of the document file

[0810] The server checks whether the received file is a PDF or presentation file (e.g., PPTX). This allows it to process only compatible formats. The server checks the file extension and returns an error message for files that are not in the required format.

[0811] 3. Document file analysis and text extraction

[0812] The server selects the appropriate parsing method depending on the received file format and extracts text data from the document file. For PDF files, it uses the pdfminer library to extract text. For presentation files, it uses the python-pptx library to extract the text of each slide.

[0813] 4. Generate program code

[0814] The server generates program code based on the extracted text data. Specifically, it uses OpenAI's API to automatically generate HTML, CSS, and JavaScript code. The generated code is essential for providing the appearance and functionality of the web page.

[0815] 5. Generated Code Output

[0816] The generated program code is sent from the server to the user's device, where it is displayed in a browser and can be downloaded or copied by the user.

[0817] The following is a concrete example of this system:

[0818] Example 1: Creating a web page from a PDF file

[0819] A user creates a PDF file named "example.pdf" and uploads it to the system. The server receives the file and verifies that it is in PDF format. It then uses the pdfminer library to extract the text data and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's device, where it can be used as a web page.

[0820] Example 2: Generating a web page from a presentation file

[0821] A user creates a presentation file named "example.pptx" and uploads it to the system. The server receives the file and verifies that it is a presentation file. It then uses the python-pptx library to extract the text from each slide and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's device, where it can be used as a web page.

[0822] This concludes the description of the present invention. The system allows users to quickly and easily create rich web pages without specialized coding skills.

[0823] The processing flow will be explained below.

[0824] Step 1: Prepare a user-created PDF or presentation file.

[0825] A user creates a PDF or presentation file to represent the design of a web page, for example, a file called "example.pptx."

[0826] Step 2: Upload the prepared file to the server.

[0827] The user accesses the system, selects the file from the interface for uploading the created file, and clicks the upload button.

[0828] Step 3: The device sends the selected file to the server.

[0829] The device sends the file selected by the user to the server as an HTTP POST request, with the destination endpoint being " / upload."

[0830] Step 4: The server receives the file and stores it temporarily.

[0831] The server receives the HTTP request and saves the uploaded file (e.g., "example.pptx") in a temporary directory (e.g., " / tmp").

[0832] Step 5: The server checks the file format.

[0833] The server checks the file extension of the saved file to ensure it is a PDF or presentation file (e.g., PPTX), and generates an error message for any other file type.

[0834] Step 6: The server parses the file and extracts the text data.

[0835] The server extracts the text data using an appropriate library depending on the file format.

[0836] For PDF files, the server uses the pdfminer library to extract the text.

[0837] For presentation files, the server uses the python-pptx library to extract the text of each slide.

[0838] Step 7: The server generates program code based on the extracted text data.

[0839] The server sends the extracted text data to OpenAI's API and generates program code (HTML, CSS, JavaScript) by specifying a prompt such as "Please generate HTML and CSS code."

[0840] Step 8: The server outputs the generated program code to the user terminal.

[0841] The server packages the generated program code in JSON format and returns it to the user's device as an HTTP response.

[0842] Step 9: The terminal displays the code received from the server.

[0843] The terminal displays the received program code on a user interface, allowing the user to download or copy the code.

[0844] Step 10: The user creates a web page using the code they received.

[0845] Users can incorporate the displayed program code into their own web projects, edit and adjust it as needed, and complete a rich web page.

[0846] In this way, the system helps users automatically generate rich web pages from existing document files without requiring specialized knowledge.

[0847] Example 1

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

[0849] There is a demand for a system that allows users to quickly and easily generate rich web pages from document files they have created without having specialized coding skills. Conventional methods require specialized knowledge and time to extract text data from document files and convert it into web page code. The challenge is to solve this problem and provide a method that allows users to easily generate web pages.

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

[0851] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for using a generative model to generate program code based on the extracted text data, and means for outputting the generated program code, thereby enabling users to quickly and easily create rich web pages without specialized coding skills.

[0852] "User" refers to any individual or entity that intends to use the System to generate a Web page from a document file.

[0853] "Document File" refers to a PDF file or electronic slideshow file (presentation file) created by a User and uploaded to the System.

[0854] "Means for receiving" refers to the method or process by which the server receives the document file sent from the user's terminal.

[0855] "Means for verifying" refers to the method or process for verifying that the format of the document file received by the server is in the specified format (PDF or electronic slideshow file).

[0856] "Means for analyzing and extracting" refers to the method or process by which the server analyzes the contents of the document file and extracts text data therefrom.

[0857] "Means of using a generative model" refers to the method or process for generating program code (HTML, CSS, JavaScript) using a generative AI model based on extracted text data.

[0858] "Means for outputting" refers to a method or process for providing the generated program code to the user.

[0859] The "predetermined format" refers to a file format that the system can handle, specifically a PDF format or an electronic slideshow file format (presentation file format).

[0860] A "generative model" refers to a machine learning or artificial intelligence model used to generate program code based on text data.

[0861] A "prompt statement" is a document or instruction that is input to a generative model and is used to specify the content and format of the program code to be generated.

[0862] This invention relates to a system for generating rich web pages from document files created by users. The system provides a series of processes that allow users to upload document files and automatically generate code for web pages from those files.

[0863] System Configuration

[0864] Hardware

[0865] The system consists of the following hardware:

[0866] 1. Server: Receives files, analyzes them, inputs them into the generative model, generates program code, and outputs it.

[0867] 2. Terminal: The user uploads a document file and receives and displays the generated web page code.

[0868] software

[0869] The system consists of the following software:

[0870] 1. File receiving module: Receives document files uploaded by users.

[0871] 2. Format Verification Module: Verifies that the received file is in the required format (PDF or electronic slideshow file).

[0872] 3. Text Extraction Module: Analyzes the content of document files and extracts text data. Specifically, it uses the pdfminer library for PDF files and the python-pptx library for presentation files.

[0873] 4. Code generation module: Generates HTML, CSS, and JavaScript program code based on the extracted text data using a generative AI model. The generative model uses OpenAI's API.

[0874] 5. Code output module: Provides the generated program code to the user.

[0875] Example of operation

[0876] Example 1: Creating a web page from a PDF file

[0877] 1. A user creates a PDF file called "example.pdf" and uploads it to the system via the terminal.

[0878] 2. The server uses the file receiving module to receive the file and the format confirmation module to confirm that it is in PDF format.

[0879] 3. The server uses the pdfminer library to extract text data from the PDF file.

[0880] 4. Based on the extracted text data, generate a prompt sentence like the following and input it into the generative model:

[0881] Given the following user-provided text, generate HTML, CSS, and JavaScript code for a rich web page.

[0882] Text data: "Extracted text goes here."

[0883] 5. The generative AI model generates HTML, CSS, and JavaScript code based on the input prompt.

[0884] 6. The server receives the generated code and sends it to the terminal using the code output module.

[0885] 7. The user receives the web page code generated on their device and can view it in their browser or download it for use.

[0886] Example 2: Generating a web page from a presentation file

[0887] 1. A user creates a presentation file called "example.pptx" and uploads it to the system through the terminal.

[0888] 2. The server receives the file using the file receiving module and verifies that it is in presentation file format using the format verification module.

[0889] 3. The server uses the python-pptx library to extract text data from each slide in the presentation file.

[0890] 4. Based on the extracted text data, generate a prompt sentence like the following and input it into the generative model:

[0891] Given the following user-provided text, generate HTML, CSS, and JavaScript code for a rich web page.

[0892] Text data: "Extracted text goes here."

[0893] 5. The generative AI model generates HTML, CSS, and JavaScript code based on the input prompt.

[0894] 6. The server receives the generated code and sends it to the terminal using the code output module.

[0895] 7. The user receives the web page code generated on their device and can view it in their browser or download it for use.

[0896] The system allows users to quickly and easily create rich web pages without specialized coding skills.

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

[0898] Step 1:

[0899] The user selects a document file and uploads it to the system. The input includes the PDF or presentation file selected by the user. The output is the selected file sent to the server.

[0900] Specific behavior:

[0901] The user clicks the file selection button and a file selection dialog appears.

[0902] The user selects a document file (e.g., "example.pdf") and clicks the "Open" button.

[0903] The device sends the selected file to the server via an HTTP POST request.

[0904] Step 2:

[0905] The server checks the format of the document file received. The input includes the file extension. The output is a determination of whether the format is a specified format (PDF or presentation file).

[0906] Specific behavior:

[0907] Extract the extension of the file received by the server.

[0908] Check that the extracted file extension is ".pdf" or ".pptx".

[0909] If it is not in a supported format, the server generates an error message and returns it to the user.

[0910] Step 3:

[0911] The server analyzes the contents of document files to extract text data. The inputs include PDF or presentation files. The output is the extracted text data.

[0912] Specific behavior:

[0913] The server calls the appropriate library depending on the file format.

[0914] For PDF files, it uses the pdfminer library to extract text from each page.

[0915] For presentation files, we use the python-pptx library to extract the text from each slide.

[0916] The extracted text data is stored in memory.

[0917] Step 4:

[0918] The server generates program code (HTML, CSS, JavaScript) using a generative AI model based on the extracted text data. The input includes the extracted text data and a prompt for the generative model. The output is the generated program code.

[0919] Specific behavior:

[0920] The server generates a prompt and sets it as follows:

[0921] Given the following user-provided text, generate HTML, CSS, and JavaScript code for a rich web page.

[0922] Text data: "Extracted text goes here."

[0923] The server sends a prompt to the generative AI model (e.g., OpenAI's API).

[0924] It receives the program code returned by the generative AI model and formats it as needed.

[0925] Step 5:

[0926] The server provides the generated program code to the user, and the input includes the generated program code, and the output is transmitted to the user for display or download.

[0927] Specific behavior:

[0928] The server packages the generated HTML, CSS, and JavaScript code into an HTTP response.

[0929] The server sends an HTTP response, and the terminal receives it.

[0930] The device displays the code in the browser and allows the user to download or copy it for use.

[0931] By following these steps, users can quickly generate rich web pages without specialized coding skills.

[0932] (Application example 1)

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

[0934] Previously, for brick-and-mortar store owners to easily publish their latest promotional information and store information on a web page, specialized skills were often required, resulting in a time-consuming and labor-intensive process. Furthermore, the complex operations required made it difficult for people without technical knowledge to use. This created the challenge of making it difficult to quickly update store information online.

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

[0936] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for generating program code based on the extracted text data, means for outputting the generated program code, and means for providing the generated program code to a user via a smartphone application. This enables store owners without specialized skills to easily and quickly generate rich web pages containing promotional information and provide them to customers.

[0937] "User" means a person or entity that utilizes the system to upload document files and generate web pages.

[0938] A "document file" is a digital file format created by a user, such as a PDF or presentation file.

[0939] The "receiving means" refers to the interface and server functions that allow users to upload document files they have created to the system.

[0940] The "means for checking the format" is a function for checking that the received document file is in a specified format (PDF or presentation file).

[0941] "Means for analyzing and extracting" are algorithms and libraries for reading text data from document files and extracting the necessary information.

[0942] "Means for generating program code" refers to machine learning models and APIs for generating HTML, CSS, and JavaScript code for web pages based on extracted text data.

[0943] The "means for outputting" is a function for transmitting the generated program code to the user's terminal so that it can be displayed or saved.

[0944] A "smartphone application" is software that runs on a smartphone and allows users to upload document files and generate web pages.

[0945] The "means of providing" is a function for notifying the user of the generated program code through the smartphone application and making it available for use.

[0946] A system for implementing the present invention is for automatically generating rich web pages using document files created by users. The system comprises the following means:

[0947] 1. How to receive document files

[0948] A user uploads a PDF or presentation file they created to the app using a smartphone application. The application then sends the file from the device to the server via an HTTP request, and the server receives the request and temporarily stores the document file.

[0949] 2. Format confirmation method

[0950] The server checks whether the received document file is in PDF format or presentation file format (e.g., PPTX). Specifically, the server checks the file extension, and if it is not a supported format, it returns an error message.

[0951] 3. Analysis and Text Extraction Methods

[0952] The server selects the appropriate parsing method depending on the received file format and extracts text data from the document file: for PDF files, it uses the pdfminer library to extract text, and for presentation files, it uses the python-pptx library to extract the text of each slide.

[0953] 4. Program code generation method

[0954] The server generates program code based on the extracted text data. Specifically, it uses the OpenAI API, a generative AI model, to automatically generate HTML, CSS, and JavaScript code. This process defines the appearance and functionality of the web page based on the extracted text.

[0955] 5. Output Method

[0956] The generated program code is sent from the server to the user's smartphone application, where the user can view the generated web page and share the URL as needed.

[0957] Specific examples include the following processes:

[0958] Example 1: Creating a web page from a PDF file

[0959] A user creates a PDF file named "example.pdf" and uploads it to the system. The server receives the file and verifies that it is in PDF format. It then uses the pdfminer library to extract text data and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's smartphone application, which makes it available as a web page.

[0960] Example 2: Generating a web page from a presentation file

[0961] A user creates a presentation file named "example.pptx" and uploads it to the system. The server receives the file and verifies that it is a presentation file. It then uses the python-pptx library to extract the text from each slide and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's smartphone application, which makes it available as a web page.

[0962] Example prompt sentence:

[0963] Generate a rich web page using the following text:

[0964] Our new fall menu has arrived!

[0965] Our recommended dishes are mushroom risotto and pumpkin soup. We look forward to your visit.

[0966] This allows store owners to easily and quickly generate rich web pages containing promotional information and provide them to customers, even if they do not have specialized skills.

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

[0968] Step 1:

[0969] A user uploads a PDF or presentation file using a smartphone application. The user selects the file within the application, and the selected document file is sent to the server via the application.

[0970] Input: User-created document file (PDF or PPTX)

[0971] Output: The document file sent to the server

[0972] Step 2:

[0973] The server verifies that the received document file is in the specified format (PDF or PPTX). The server checks the file extension and returns an error message if the format is not supported.

[0974] Input: Document file sent to the server

[0975] Output: Result of format check (success or error message)

[0976] Step 3:

[0977] The server selects the appropriate parsing method depending on the format of the received document file and extracts text data from the document file. For PDF files, it uses the pdfminer library to extract text, and for presentation files, it uses the python-pptx library to extract the text of each slide.

[0978] Input: A document file that has passed the format check

[0979] Output: Extracted text data

[0980] Step 4:

[0981] The server generates web page program code based on the extracted text data. Specifically, it uses the OpenAI API, a generative AI model, to generate HTML, CSS, and JavaScript code. The server sends the text data to the API as a prompt and receives the generated code in response.

[0982] Input: Extracted text data

[0983] Output: Generated HTML, CSS, and JavaScript code

[0984] Step 5:

[0985] The server provides the generated program code to the user through a smartphone application, which receives the generated code and displays it as a web page in the user's browser.

[0986] Input: Generated HTML, CSS, and JavaScript code

[0987] Output: A web page displayed on the user's smartphone application.

[0988] This allows store owners to easily and quickly generate rich web pages containing promotional information and provide them to customers, even if they do not have specialized skills.

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

[0990] This system allows users to easily generate rich web pages using document files created by the user. This system has the unique feature of adjusting the design and content of the web page based on the content of the document file as well as the user's emotional information. The system's main functions are as follows:

[0991] 1. Receiving document files

[0992] A user creates a PDF or presentation file to represent a web page design, for example, a file called "example.pptx," and then uses the interface to upload the created file to the system.

[0993] 2. Check the file format

[0994] The server checks the extension of the received file to ensure that it is a PDF or presentation file (e.g., PPTX), allowing it to process only compatible formats.

[0995] 3. Document file analysis and text extraction

[0996] The server extracts the text data using the appropriate library depending on the file format: for PDF files, it uses the pdfminer library to extract the text, and for presentation files, it uses the python-pptx library to extract the text of each slide.

[0997] 4. Emotion Recognition by Emotion Engine

[0998] The server includes an emotion engine for recognizing emotions from the user's facial expressions and voice. This emotion engine analyzes the user's facial expressions and voice via a camera and microphone, and recognizes emotions such as joy, sadness, surprise, and anger in real time.

[0999] 5. Generating Program Code

[1000] The server uses OpenAI's API to generate HTML, CSS, and JavaScript code based on the extracted text and the user's recognized emotion. For example, if the user expresses surprise, the program can incorporate design elements and effects that match that emotion.

[1001] 6. Generated Code Output

[1002] The generated program code is sent from the server to the user's device, where it is displayed in a browser and can be downloaded or copied by the user.

[1003] For example:

[1004] Example 1: Creating a web page from a PDF file

[1005] A user creates a PDF file named "example.pdf" and uploads it to the system. The server receives the file and verifies that it is in PDF format. It then extracts the text data using the pdfminer library and generates HTML, CSS, and JavaScript code via OpenAI's API. It also uses an emotion engine to recognize the user's emotions. For example, if the user is expressing joy, it generates code with a design that matches that emotion.

[1006] Example 2: Generating a web page from a presentation file

[1007] A user creates a presentation file named "example.pptx" and uploads it to the system. The server receives the file, verifies that it is a presentation file, extracts text data using the python-pptx library, and generates HTML, CSS, and JavaScript code via OpenAI's API. The emotion engine recognizes the user's emotions and generates code with dynamic effects, for example, if the user is excited.

[1008] This concludes the "Mode for Carrying Out the Invention" of the present invention. This system not only allows users to quickly and easily create rich web pages without requiring specialized coding skills, but also allows for customization according to the user's emotions.

[1009] The processing flow will be explained below.

[1010] Step 1: Prepare a user-created PDF or presentation file.

[1011] A user creates a PDF or presentation file to represent the design of a web page, for example, a file called "example.pptx."

[1012] Step 2: Upload the prepared file to the server.

[1013] The user accesses the system, selects the file from the interface for uploading the created file, and clicks the upload button.

[1014] Step 3: The device sends the selected file to the server.

[1015] The device sends the file selected by the user to the server as an HTTP POST request, with the destination endpoint being " / upload."

[1016] Step 4: The server receives the file and stores it temporarily.

[1017] The server receives the HTTP request and saves the uploaded file (e.g., "example.pptx") in a temporary directory (e.g., " / tmp").

[1018] Step 5: The server checks the file format.

[1019] The server checks the file extension of the saved file to ensure it is a PDF or presentation file (e.g., PPTX), and generates an error message for any other file type.

[1020] Step 6: The server parses the file and extracts the text data.

[1021] The server extracts the text data using an appropriate library depending on the file format.

[1022] For PDF files, the server uses the pdfminer library to extract the text.

[1023] For presentation files, the server uses the python-pptx library to extract the text of each slide.

[1024] Step 7: The server uses the emotion engine to recognize the user's emotion.

[1025] When a user uploads a file, the camera and microphone capture the user's facial expressions and voice. The server receives this data and analyzes the user's emotions using an emotion engine. For example, if the user is smiling and having fun, that emotion is recognized.

[1026] Step 8: The server generates a program code based on the extracted text data and the recognized emotion data.

[1027] The server combines the extracted text data with the recognized emotion data and sends it to OpenAI's API to generate HTML, CSS, and JavaScript code. For example, if the user is having fun, the code will be generated to include colors and design elements that match that emotion.

[1028] Step 9: The server outputs the generated program code to the user terminal.

[1029] The server packages the generated program code in JSON format and returns it to the user's device as an HTTP response.

[1030] Step 10: The terminal displays the code received from the server.

[1031] The terminal displays the received program code on a user interface, allowing the user to download or copy the code.

[1032] Step 11: The user creates a web page using the code they received.

[1033] Users can incorporate the displayed program code into their own web projects, edit and adjust it as needed, and complete a rich web page.

[1034] These are the specific processing steps of this system, which allows users to quickly and easily create rich web pages without specialized coding skills, and also customize them to suit individual emotions.

[1035] Example 2

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

[1037] Conventional web page generation systems based on document files have difficulty automatically generating designs and content that reflect the user's intentions and emotions, forcing the user to make manual adjustments. Furthermore, they lack the appropriate text extraction and analysis processes that depend on the format and content of the document file, and the process of generating program code that reflects the results. Therefore, there is a need for a system that can solve these issues and enable users to easily generate rich web pages that reflect their emotions.

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

[1039] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for acquiring emotion data from the user's device in real time, means for generating program code based on the extracted text data and the acquired emotion data, and means for outputting the generated program code. This enables users to quickly and easily generate rich web pages that reflect the user's emotions, even if they do not have specialized coding skills.

[1040] A "document file" is a data format such as a PDF or presentation file created by a user.

[1041] "Means for receiving" refers to a mechanism such as an interface or protocol that allows the server to obtain document files created by users.

[1042] "Predetermined formats" refers to specific file formats that the system can support, specifically PDF and presentation files (e.g., PPTX).

[1043] The "verification means" is a function for verifying that the format of the document file received by the server is a predetermined format.

[1044] "Means of analysis and extraction" refers to the techniques and processes required to extract text data from document files and understand their contents.

[1045] "Emotion data" is information about emotions acquired from the user's facial expressions and voice, and includes joy, sadness, surprise, anger, and the like.

[1046] "Means for acquiring data in real time" refers to a technology that uses the user's device (camera or microphone) to instantly analyze the user's current facial expressions and voice, and collects emotional data as a result.

[1047] The "means for generating program code" is a technology that automatically creates web page generation code such as HTML, CSS, and JavaScript based on the extracted text data and acquired emotion data.

[1048] The "means for outputting" is a mechanism for transmitting the generated program code to the user's terminal so that it can be displayed on the browser or downloaded.

[1049] A "machine learning model" is an algorithm or model that learns patterns and predictions from data and performs a specific task (in this case, converting text and emotion data into program code).

[1050] This invention is a system for quickly and easily generating rich web pages using document files created by users. This system has the unique feature of adjusting the design and content of web pages based on the content of the document file as well as the user's emotional information. This system mainly uses the following hardware and software:

[1051] First, a user creates a PDF or presentation file to represent the design of a web page. For example, they create a file called "example.pptx" and upload it to the system. The user then uses an interface (such as a browser-based upload form) to upload the file.

[1052] The server receives the uploaded document file and checks its extension. If the file format is PDF, it uses the pdfminer library to extract text data. On the other hand, if the file format is a presentation file (PPTX), it uses the python-pptx library to extract the text of each slide. For example, to extract text from a PDF file, the following specific process is performed:

[1053] Parse the PDF file using PDFParser from pdfminer.six.

[1054] Use PDFPageInterpreter to extract the text content of each page.

[1055] The server also collects emotion data in real time from the user's device. The emotion data is collected through the user's camera and microphone, and analyzed by the emotion engine. The emotion engine works as follows:

[1056] Facial expression recognition: Image recognition technology is used to extract the features of the user's facial expression and classify their emotions based on this.

[1057] Speech recognition: Analyzes voice data obtained from a microphone and evaluates the tone and rate to determine emotion.

[1058] The server then uses OpenAI's API to generate HTML, CSS, and JavaScript code based on the extracted text and emotion data. For example, if the user expresses joy, the generated web page will incorporate bright colors and animation effects.

[1059] The device receives the generated HTML, CSS, and JavaScript code sent by the server and displays it in the browser, where the user can download and edit the code.

[1060] For example:

[1061] Example 1: Creating a web page from a PDF file

[1062] 1. A user creates a PDF file named "example.pdf" and uploads it to the system.

[1063] 2. The server checks the file format and extracts the text data from the PDF file using the pdfminer library.

[1064] 3. The server uses the emotion engine to recognize the user's emotion of joy.

[1065] 4. The server uses OpenAI's API to generate HTML, CSS, and JavaScript code for a brightly colored web page.

[1066] 5. The terminal will display the generated code in your browser.

[1067] Example prompt:

[1068] "If the user is expressing joy, generate a web page with text extracted from the PDF, a bright key color, and a vibrant layout."

[1069] Example 2: Generating a web page from a presentation file

[1070] 1. A user creates a presentation file named "example.pptx" and uploads it to the system.

[1071] 2. The server checks the file format and extracts the text data from the presentation file using the python-pptx library.

[1072] 3. The server uses the emotion engine to recognize the user's emotion of excitement.

[1073] 4. The server uses OpenAI's API to generate the HTML, CSS, and JavaScript code for the web page, including the dynamic effects.

[1074] 5. The terminal will display the generated code in your browser.

[1075] Example prompt:

[1076] "If your users are excited, generate a web page with the text extracted from the PPTX and incorporate dynamic design with animation effects."

[1077] This system allows users to quickly and easily generate rich web pages without specialized coding skills, and also allows them to customize them according to their emotions.

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

[1079] Step 1: Upload your document files

[1080] The user creates a PDF or presentation file (e.g., "example.pptx") and uploads the file using the system's file upload interface.

[1081] Input: User-created document file

[1082] Output: Document file uploaded to the server

[1083] Step 2: Check the file format

[1084] The server checks the file extension of the uploaded document. If the file format is not PDF or PPTX, it returns an error message to the user. For example, if the file extension is .txt, it displays the message "Unsupported file format."

[1085] Input: Uploaded document file

[1086] Output: File format check result (PDF / PPTX or error message)

[1087] Step 3: Analyze the document file and extract text

[1088] The server extracts the text using the appropriate library depending on the file format.

[1089] For PDF files: Parse the PDF file using PDFParser from pdfminer.six and extract the text content of each page with PDFPageInterpreter.

[1090] For presentation files (PPTX): Use the python-pptx library to read the PPTX file and extract the text of each slide, along with the text styles (font, size, color, etc.) within each slide.

[1091] Input: Document file (PDF or PPTX)

[1092] Output: Extracted text data

[1093] Step 4: Emotion Recognition with the Emotion Engine

[1094] The server acquires the user's emotional data in real time through the device's camera and microphone, and the emotion engine analyzes the acquired data to determine the user's emotions (joy, sadness, surprise, anger, etc.).

[1095] Facial Expression Recognition: Using image recognition technology, the feature points of the user's facial expression are analyzed to classify emotions.

[1096] Speech recognition: Analyzes voice data obtained from the microphone and determines emotions from the tone and speed of the voice.

[1097] Input: Real-time data from camera and microphone

[1098] Output: User emotion data

[1099] Step 5: Generate code for the web page

[1100] The server uses OpenAI's API to generate HTML, CSS, and JavaScript code based on the extracted text data and acquired emotion data.

[1101] Emotional design elements: For example, if the user is expressing the emotion of joy, incorporate bright colors and animated designs.

[1102] Use of generative AI models: Generate prompts based on text and emotion data, and input them into OpenAI's API to generate program code.

[1103] Input: Text data, emotion data, prompt sentence

[1104] Output: Generated HTML, CSS, and JavaScript code

[1105] Step 6: Outputting the generated code

[1106] The device receives the generated HTML, CSS, and JavaScript code sent from the server and displays it in the browser. The user can download and edit this code, allowing for final confirmation and correction of the generated web page.

[1107] Input: Generated HTML, CSS, and JavaScript code

[1108] Output: Web page displayed in browser, and downloadable program code

[1109] (Application example 2)

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

[1111] Conventional web page generation systems using document files were unable to adjust design and content to take user emotions into account, and could only provide generic designs. Furthermore, it was difficult to display promotional content that responded to customer emotions in real time, especially in brick-and-mortar stores. This led to the problem of being unable to implement effective marketing that responded to customer emotions.

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

[1113] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for generating program code based on the extracted text data and user emotion data, and means for displaying the generated program code in real time on a display device in the requesting store. This allows users to utilize emotion recognition technology to display rich web pages and promotional content in real time in physical stores in response to customer emotions.

[1114] "User" means a person who uses this system to upload document files or use generated codes.

[1115] A "Document File" is a PDF or presentation format file that contains content created by a user.

[1116] The "means for receiving" is a means for uploading a document file created by a user to the system.

[1117] "Specified format" refers to a PDF or presentation format file that the system can handle.

[1118] The "verification means" is a means for checking whether the received document file is in a predetermined format.

[1119] The "means for analyzing and extracting" is a means for analyzing text data from a document file and extracting necessary information.

[1120] "Emotion data" refers to emotional information obtained by analyzing the user's facial expressions and voice.

[1121] The "means for generating program code" refers to a means for generating code such as HTML, CSS, or JavaScript based on the extracted text data and user emotion data.

[1122] The "display device in the requesting store" refers to a video display device such as a display, screen, or smart glasses installed in a physical store.

[1123] The "means for displaying in real time" refers to a means for immediately displaying the generated program code on a display device in the requesting store.

[1124] A "generative AI model" is an AI technology used to generate program code from text data and emotion data using machine learning techniques.

[1125] This invention relates to a system that uses document files created by users to display rich web pages and promotional content in real time on display devices in physical stores. This system has the unique feature of adjusting the design and content based on the content of the document file as well as the user's emotional data. The configuration and operation of this system are described in detail below.

[1126] The system consists of the following main steps:

[1127] 1. Receiving document files

[1128] A user creates a PDF or presentation file (PPTX) to represent the design of a web page or promotional content, and uploads it to the system. For example, a file named "promotion.pptx" is created. The user then uses the interface to upload the created file to the system.

[1129] 2. Check the file format

[1130] The server checks the extension of the received file to ensure it is a supported format (PDF or presentation file), allowing for proper control over the file formats that are processed.

[1131] 3. Document file analysis and text extraction

[1132] The server extracts the text data using the appropriate library depending on the file format (pdfminer for PDFs, python-pptx for presentation files).

[1133] 4. Emotion Data Recognition

[1134] The server includes an emotion engine that analyzes the user's facial expressions and voice via a camera and microphone to recognize emotion data. This emotion engine recognizes the user's emotions, such as joy, sadness, surprise, and anger, in real time.

[1135] 5. Generating Program Code

[1136] The server uses a generative AI model (e.g., OpenAI's API) to generate HTML, CSS, and JavaScript code based on the extracted text data and the user's recognized emotion data, dynamically adjusting design elements and effects according to the emotion data.

[1137] 6. Output and View the Generated Code

[1138] The generated program code is sent in real time from the server to the display device in the requesting store, which then displays a rich web page or promotional content that reflects the user's emotions.

[1139] As a concrete example, consider a case where a store salesperson creates a presentation for a new product launch in PPTX format and uploads it to the system. The system extracts text from the presentation file and recognizes the emotions of customers visiting the physical store by reading their facial expressions via a camera. For example, if a customer expresses surprise, the system generates a web page with dynamic and vivid effects, which is displayed in real time on in-store displays and on the salesperson's smart glasses. This process allows the store to implement effective promotions that are in line with customer emotions.

[1140] Prompt Sentence Examples

[1141] Generate a HTML / CSS / JS code for a web page with the following content:

[1142] Welcome to the new product launch event! Today's menu is as follows: 1. New product introduction 2. Special promotion 3. Q&A. Make it vibrant and suited to surprise emotion.

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

[1144] Step 1:

[1145] Receive document files created by users

[1146] How it works: A user uploads a PDF or presentation file (PPTX) to the system.

[1147] Input: A user-created document file.

[1148] Output: The document file is saved on the server.

[1149] Step 2:

[1150] Checking the format of the received document file

[1151] What happens: The server checks the file extension and sees if it is in a supported format (PDF or PPTX).

[1152] Input: A document file stored on the server.

[1153] Output: Verification that the file is in a supported format.

[1154] Step 3:

[1155] Analyze and extract text data from document files

[1156] How it works: The server extracts text from PDF files using the pdfminer library, or from PPTX files using the python-pptx library.

[1157] Input: Authenticated document file.

[1158] Output: The extracted text data.

[1159] Step 4:

[1160] Recognizing Emotional Data

[1161] How it works: The server analyzes the user's facial expressions and voice through the camera and microphone, and uses an emotion engine to recognize emotional data.

[1162] Input: User facial and voice data captured by camera and microphone.

[1163] Output: Recognized user emotion data.

[1164] Step 5:

[1165] Generate program code

[1166] How it works: The server uses a generative AI model (e.g., OpenAI's API) to generate HTML, CSS, and JavaScript code based on the extracted text and emotion data.

[1167] Input: Extracted text data and recognized emotion data.

[1168] Output: Generated HTML, CSS, and JavaScript code.

[1169] Step 6:

[1170] Print the generated code

[1171] Operation: The generated program code is sent in real time from the server to the display device in the requesting store.

[1172] Input: Generated HTML, CSS, and JavaScript code.

[1173] Output: Rich web pages and promotional content displayed on display devices within the requested store.

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

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

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

[1177] [Fourth embodiment]

[1178] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

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

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

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

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

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

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

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

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

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

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

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

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

[1191] This system allows users to easily generate rich web pages using document files they have created. The system has the following main functions:

[1192] 1. Receiving document files

[1193] The user uploads the PDF or presentation file they created to the system. At this time, the terminal selects the file and sends it to the server. The server receives the HTTP request and temporarily stores the file.

[1194] 2. Check the format of the document file

[1195] The server checks whether the received file is a PDF or presentation file (e.g., PPTX). This allows it to process only compatible formats. The server checks the file extension and returns an error message for files that are not in the required format.

[1196] 3. Document file analysis and text extraction

[1197] The server selects the appropriate parsing method depending on the received file format and extracts text data from the document file. For PDF files, it uses the pdfminer library to extract text. For presentation files, it uses the python-pptx library to extract the text of each slide.

[1198] 4. Generate program code

[1199] The server generates program code based on the extracted text data. Specifically, it uses OpenAI's API to automatically generate HTML, CSS, and JavaScript code. The generated code is essential for providing the appearance and functionality of the web page.

[1200] 5. Generated Code Output

[1201] The generated program code is sent from the server to the user's device, where it is displayed in a browser and can be downloaded or copied by the user.

[1202] The following is a concrete example of this system:

[1203] Example 1: Creating a web page from a PDF file

[1204] A user creates a PDF file named "example.pdf" and uploads it to the system. The server receives the file and verifies that it is in PDF format. It then uses the pdfminer library to extract the text data and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's device, where it can be used as a web page.

[1205] Example 2: Generating a web page from a presentation file

[1206] A user creates a presentation file named "example.pptx" and uploads it to the system. The server receives the file and verifies that it is a presentation file. It then uses the python-pptx library to extract the text from each slide and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's device, where it can be used as a web page.

[1207] This concludes the description of the present invention. The system allows users to quickly and easily create rich web pages without specialized coding skills.

[1208] The processing flow will be explained below.

[1209] Step 1: Prepare a user-created PDF or presentation file.

[1210] A user creates a PDF or presentation file to represent the design of a web page, for example, a file called "example.pptx."

[1211] Step 2: Upload the prepared file to the server.

[1212] The user accesses the system, selects the file from the interface for uploading the created file, and clicks the upload button.

[1213] Step 3: The device sends the selected file to the server.

[1214] The device sends the file selected by the user to the server as an HTTP POST request, with the destination endpoint being " / upload."

[1215] Step 4: The server receives the file and stores it temporarily.

[1216] The server receives the HTTP request and saves the uploaded file (e.g., "example.pptx") in a temporary directory (e.g., " / tmp").

[1217] Step 5: The server checks the file format.

[1218] The server checks the file extension of the saved file to ensure it is a PDF or presentation file (e.g., PPTX), and generates an error message for any other file type.

[1219] Step 6: The server parses the file and extracts the text data.

[1220] The server extracts the text data using an appropriate library depending on the file format.

[1221] For PDF files, the server uses the pdfminer library to extract the text.

[1222] For presentation files, the server uses the python-pptx library to extract the text of each slide.

[1223] Step 7: The server generates program code based on the extracted text data.

[1224] The server sends the extracted text data to OpenAI's API and generates program code (HTML, CSS, JavaScript) by specifying a prompt such as "Please generate HTML and CSS code."

[1225] Step 8: The server outputs the generated program code to the user terminal.

[1226] The server packages the generated program code in JSON format and returns it to the user's device as an HTTP response.

[1227] Step 9: The terminal displays the code received from the server.

[1228] The terminal displays the received program code on a user interface, allowing the user to download or copy the code.

[1229] Step 10: The user creates a web page using the code they received.

[1230] Users can incorporate the displayed program code into their own web projects, edit and adjust it as needed, and complete a rich web page.

[1231] In this way, the system helps users automatically generate rich web pages from existing document files without requiring specialized knowledge.

[1232] Example 1

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

[1234] There is a demand for a system that allows users to quickly and easily generate rich web pages from document files they have created without having specialized coding skills. Conventional methods require specialized knowledge and time to extract text data from document files and convert it into web page code. The challenge is to solve this problem and provide a method that allows users to easily generate web pages.

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

[1236] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for using a generative model to generate program code based on the extracted text data, and means for outputting the generated program code, thereby enabling users to quickly and easily create rich web pages without specialized coding skills.

[1237] "User" refers to any individual or entity that intends to use the System to generate a Web page from a document file.

[1238] "Document File" refers to a PDF file or electronic slideshow file (presentation file) created by a User and uploaded to the System.

[1239] "Means for receiving" refers to the method or process by which the server receives the document file sent from the user's terminal.

[1240] "Means for verifying" refers to the method or process for verifying that the format of the document file received by the server is in the specified format (PDF or electronic slideshow file).

[1241] "Means for analyzing and extracting" refers to the method or process by which the server analyzes the contents of the document file and extracts text data therefrom.

[1242] "Means of using a generative model" refers to the method or process for generating program code (HTML, CSS, JavaScript) using a generative AI model based on extracted text data.

[1243] "Means for outputting" refers to a method or process for providing the generated program code to the user.

[1244] The "predetermined format" refers to a file format that the system can handle, specifically a PDF format or an electronic slideshow file format (presentation file format).

[1245] A "generative model" refers to a machine learning or artificial intelligence model used to generate program code based on text data.

[1246] A "prompt statement" is a document or instruction that is input to a generative model and is used to specify the content and format of the program code to be generated.

[1247] This invention relates to a system for generating rich web pages from document files created by users. The system provides a series of processes that allow users to upload document files and automatically generate code for web pages from those files.

[1248] System Configuration

[1249] Hardware

[1250] The system consists of the following hardware:

[1251] 1. Server: Receives files, analyzes them, inputs them into the generative model, generates program code, and outputs it.

[1252] 2. Terminal: The user uploads a document file and receives and displays the generated web page code.

[1253] software

[1254] The system consists of the following software:

[1255] 1. File receiving module: Receives document files uploaded by users.

[1256] 2. Format Verification Module: Verifies that the received file is in the required format (PDF or electronic slideshow file).

[1257] 3. Text Extraction Module: Analyzes the content of document files and extracts text data. Specifically, it uses the pdfminer library for PDF files and the python-pptx library for presentation files.

[1258] 4. Code generation module: Generates HTML, CSS, and JavaScript program code based on the extracted text data using a generative AI model. The generative model uses OpenAI's API.

[1259] 5. Code output module: Provides the generated program code to the user.

[1260] Example of operation

[1261] Example 1: Creating a web page from a PDF file

[1262] 1. A user creates a PDF file called "example.pdf" and uploads it to the system via the terminal.

[1263] 2. The server uses the file receiving module to receive the file and the format confirmation module to confirm that it is in PDF format.

[1264] 3. The server uses the pdfminer library to extract text data from the PDF file.

[1265] 4. Based on the extracted text data, generate a prompt sentence like the following and input it into the generative model:

[1266] Given the following user-provided text, generate HTML, CSS, and JavaScript code for a rich web page.

[1267] Text data: "Extracted text goes here."

[1268] 5. The generative AI model generates HTML, CSS, and JavaScript code based on the input prompt.

[1269] 6. The server receives the generated code and sends it to the terminal using the code output module.

[1270] 7. The user receives the web page code generated on their device and can view it in their browser or download it for use.

[1271] Example 2: Generating a web page from a presentation file

[1272] 1. A user creates a presentation file called "example.pptx" and uploads it to the system through the terminal.

[1273] 2. The server receives the file using the file receiving module and verifies that it is in presentation file format using the format verification module.

[1274] 3. The server uses the python-pptx library to extract text data from each slide in the presentation file.

[1275] 4. Based on the extracted text data, generate a prompt sentence like the following and input it into the generative model:

[1276] Given the following user-provided text, generate HTML, CSS, and JavaScript code for a rich web page.

[1277] Text data: "Extracted text goes here."

[1278] 5. The generative AI model generates HTML, CSS, and JavaScript code based on the input prompt.

[1279] 6. The server receives the generated code and sends it to the terminal using the code output module.

[1280] 7. The user receives the web page code generated on their device and can view it in their browser or download it for use.

[1281] The system allows users to quickly and easily create rich web pages without specialized coding skills.

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

[1283] Step 1:

[1284] The user selects a document file and uploads it to the system. The input includes the PDF or presentation file selected by the user. The output is the selected file sent to the server.

[1285] Specific behavior:

[1286] The user clicks the file selection button and a file selection dialog appears.

[1287] The user selects a document file (e.g., "example.pdf") and clicks the "Open" button.

[1288] The device sends the selected file to the server via an HTTP POST request.

[1289] Step 2:

[1290] The server checks the format of the document file received. The input includes the file extension. The output is a determination of whether the format is a specified format (PDF or presentation file).

[1291] Specific behavior:

[1292] Extract the extension of the file received by the server.

[1293] Check that the extracted file extension is ".pdf" or ".pptx".

[1294] If it is not in a supported format, the server generates an error message and returns it to the user.

[1295] Step 3:

[1296] The server analyzes the contents of document files to extract text data. The inputs include PDF or presentation files. The output is the extracted text data.

[1297] Specific behavior:

[1298] The server calls the appropriate library depending on the file format.

[1299] For PDF files, it uses the pdfminer library to extract text from each page.

[1300] For presentation files, we use the python-pptx library to extract the text from each slide.

[1301] The extracted text data is stored in memory.

[1302] Step 4:

[1303] The server generates program code (HTML, CSS, JavaScript) using a generative AI model based on the extracted text data. The input includes the extracted text data and a prompt for the generative model. The output is the generated program code.

[1304] Specific behavior:

[1305] The server generates a prompt and sets it as follows:

[1306] Given the following user-provided text, generate HTML, CSS, and JavaScript code for a rich web page.

[1307] Text data: "Extracted text goes here."

[1308] The server sends a prompt to the generative AI model (e.g., OpenAI's API).

[1309] It receives the program code returned by the generative AI model and formats it as needed.

[1310] Step 5:

[1311] The server provides the generated program code to the user, and the input includes the generated program code, and the output is transmitted to the user for display or download.

[1312] Specific behavior:

[1313] The server packages the generated HTML, CSS, and JavaScript code into an HTTP response.

[1314] The server sends an HTTP response, and the terminal receives it.

[1315] The device displays the code in the browser and allows the user to download or copy it for use.

[1316] By following these steps, users can quickly generate rich web pages without specialized coding skills.

[1317] (Application example 1)

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

[1319] Previously, for brick-and-mortar store owners to easily publish their latest promotional information and store information on a web page, specialized skills were often required, resulting in a time-consuming and labor-intensive process. Furthermore, the complex operations required made it difficult for people without technical knowledge to use. This created the challenge of making it difficult to quickly update store information online.

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

[1321] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for generating program code based on the extracted text data, means for outputting the generated program code, and means for providing the generated program code to a user via a smartphone application. This enables store owners without specialized skills to easily and quickly generate rich web pages containing promotional information and provide them to customers.

[1322] "User" means a person or entity that utilizes the system to upload document files and generate web pages.

[1323] A "document file" is a digital file format created by a user, such as a PDF or presentation file.

[1324] The "receiving means" refers to the interface and server functions that allow users to upload document files they have created to the system.

[1325] The "means for checking the format" is a function for checking that the received document file is in a specified format (PDF or presentation file).

[1326] "Means for analyzing and extracting" are algorithms and libraries for reading text data from document files and extracting the necessary information.

[1327] "Means for generating program code" refers to machine learning models and APIs for generating HTML, CSS, and JavaScript code for web pages based on extracted text data.

[1328] The "means for outputting" is a function for transmitting the generated program code to the user's terminal so that it can be displayed or saved.

[1329] A "smartphone application" is software that runs on a smartphone and allows users to upload document files and generate web pages.

[1330] The "means of providing" is a function for notifying the user of the generated program code through the smartphone application and making it available for use.

[1331] A system for implementing the present invention is for automatically generating rich web pages using document files created by users. The system comprises the following means:

[1332] 1. How to receive document files

[1333] A user uploads a PDF or presentation file they created to the app using a smartphone application. The application then sends the file from the device to the server via an HTTP request, and the server receives the request and temporarily stores the document file.

[1334] 2. Format confirmation method

[1335] The server checks whether the received document file is in PDF format or presentation file format (e.g., PPTX). Specifically, the server checks the file extension, and if it is not a supported format, it returns an error message.

[1336] 3. Analysis and Text Extraction Methods

[1337] The server selects the appropriate parsing method depending on the received file format and extracts text data from the document file: for PDF files, it uses the pdfminer library to extract text, and for presentation files, it uses the python-pptx library to extract the text of each slide.

[1338] 4. Program code generation method

[1339] The server generates program code based on the extracted text data. Specifically, it uses the OpenAI API, a generative AI model, to automatically generate HTML, CSS, and JavaScript code. This process defines the appearance and functionality of the web page based on the extracted text.

[1340] 5. Output Method

[1341] The generated program code is sent from the server to the user's smartphone application, where the user can view the generated web page and share the URL as needed.

[1342] Specific examples include the following processes:

[1343] Example 1: Creating a web page from a PDF file

[1344] A user creates a PDF file named "example.pdf" and uploads it to the system. The server receives the file and verifies that it is in PDF format. It then uses the pdfminer library to extract text data and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's smartphone application, which makes it available as a web page.

[1345] Example 2: Generating a web page from a presentation file

[1346] A user creates a presentation file named "example.pptx" and uploads it to the system. The server receives the file and verifies that it is a presentation file. It then uses the python-pptx library to extract the text from each slide and generates HTML, CSS, and JavaScript code via OpenAI's API. The generated code is sent to the user's smartphone application, which makes it available as a web page.

[1347] Example prompt sentence:

[1348] Generate a rich web page using the following text:

[1349] Our new fall menu has arrived!

[1350] Our recommended dishes are mushroom risotto and pumpkin soup. We look forward to your visit.

[1351] This allows store owners to easily and quickly generate rich web pages containing promotional information and provide them to customers, even if they do not have specialized skills.

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

[1353] Step 1:

[1354] A user uploads a PDF or presentation file using a smartphone application. The user selects the file within the application, and the selected document file is sent to the server via the application.

[1355] Input: User-created document file (PDF or PPTX)

[1356] Output: The document file sent to the server

[1357] Step 2:

[1358] The server verifies that the received document file is in the specified format (PDF or PPTX). The server checks the file extension and returns an error message if the format is not supported.

[1359] Input: Document file sent to the server

[1360] Output: Result of format check (success or error message)

[1361] Step 3:

[1362] The server selects the appropriate parsing method depending on the format of the received document file and extracts text data from the document file. For PDF files, it uses the pdfminer library to extract text, and for presentation files, it uses the python-pptx library to extract the text of each slide.

[1363] Input: A document file that has passed the format check

[1364] Output: Extracted text data

[1365] Step 4:

[1366] The server generates web page program code based on the extracted text data. Specifically, it uses the OpenAI API, a generative AI model, to generate HTML, CSS, and JavaScript code. The server sends the text data to the API as a prompt and receives the generated code in response.

[1367] Input: Extracted text data

[1368] Output: Generated HTML, CSS, and JavaScript code

[1369] Step 5:

[1370] The server provides the generated program code to the user through a smartphone application, which receives the generated code and displays it as a web page in the user's browser.

[1371] Input: Generated HTML, CSS, and JavaScript code

[1372] Output: A web page displayed on the user's smartphone application.

[1373] This allows store owners to easily and quickly generate rich web pages containing promotional information and provide them to customers, even if they do not have specialized skills.

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

[1375] This system allows users to easily generate rich web pages using document files created by the user. This system has the unique feature of adjusting the design and content of the web page based on the content of the document file as well as the user's emotional information. The system's main functions are as follows:

[1376] 1. Receiving document files

[1377] A user creates a PDF or presentation file to represent a web page design, for example, a file called "example.pptx," and then uses the interface to upload the created file to the system.

[1378] 2. Check the file format

[1379] The server checks the extension of the received file to ensure that it is a PDF or presentation file (e.g., PPTX), allowing it to process only compatible formats.

[1380] 3. Document file analysis and text extraction

[1381] The server extracts the text data using the appropriate library depending on the file format: for PDF files, it uses the pdfminer library to extract the text, and for presentation files, it uses the python-pptx library to extract the text of each slide.

[1382] 4. Emotion Recognition by Emotion Engine

[1383] The server includes an emotion engine for recognizing emotions from the user's facial expressions and voice. This emotion engine analyzes the user's facial expressions and voice via a camera and microphone, and recognizes emotions such as joy, sadness, surprise, and anger in real time.

[1384] 5. Generating Program Code

[1385] The server uses OpenAI's API to generate HTML, CSS, and JavaScript code based on the extracted text and the user's recognized emotion. For example, if the user expresses surprise, the program can incorporate design elements and effects that match that emotion.

[1386] 6. Generated Code Output

[1387] The generated program code is sent from the server to the user's device, where it is displayed in a browser and can be downloaded or copied by the user.

[1388] For example:

[1389] Example 1: Creating a web page from a PDF file

[1390] A user creates a PDF file named "example.pdf" and uploads it to the system. The server receives the file and verifies that it is in PDF format. It then extracts the text data using the pdfminer library and generates HTML, CSS, and JavaScript code via OpenAI's API. It also uses an emotion engine to recognize the user's emotions. For example, if the user is expressing joy, it generates code with a design that matches that emotion.

[1391] Example 2: Generating a web page from a presentation file

[1392] A user creates a presentation file named "example.pptx" and uploads it to the system. The server receives the file, verifies that it is a presentation file, extracts text data using the python-pptx library, and generates HTML, CSS, and JavaScript code via OpenAI's API. The emotion engine recognizes the user's emotions and generates code with dynamic effects, for example, if the user is excited.

[1393] This concludes the "Mode for Carrying Out the Invention" of the present invention. This system not only allows users to quickly and easily create rich web pages without requiring specialized coding skills, but also allows for customization according to the user's emotions.

[1394] The processing flow will be explained below.

[1395] Step 1: Prepare a user-created PDF or presentation file.

[1396] A user creates a PDF or presentation file to represent the design of a web page, for example, a file called "example.pptx."

[1397] Step 2: Upload the prepared file to the server.

[1398] The user accesses the system, selects the file from the interface for uploading the created file, and clicks the upload button.

[1399] Step 3: The device sends the selected file to the server.

[1400] The device sends the file selected by the user to the server as an HTTP POST request, with the destination endpoint being " / upload."

[1401] Step 4: The server receives the file and stores it temporarily.

[1402] The server receives the HTTP request and saves the uploaded file (e.g., "example.pptx") in a temporary directory (e.g., " / tmp").

[1403] Step 5: The server checks the file format.

[1404] The server checks the file extension of the saved file to ensure it is a PDF or presentation file (e.g., PPTX), and generates an error message for any other file type.

[1405] Step 6: The server parses the file and extracts the text data.

[1406] The server extracts the text data using an appropriate library depending on the file format.

[1407] For PDF files, the server uses the pdfminer library to extract the text.

[1408] For presentation files, the server uses the python-pptx library to extract the text of each slide.

[1409] Step 7: The server uses the emotion engine to recognize the user's emotion.

[1410] When a user uploads a file, the camera and microphone capture the user's facial expressions and voice. The server receives this data and analyzes the user's emotions using an emotion engine. For example, if the user is smiling and having fun, that emotion is recognized.

[1411] Step 8: The server generates a program code based on the extracted text data and the recognized emotion data.

[1412] The server combines the extracted text data with the recognized emotion data and sends it to OpenAI's API to generate HTML, CSS, and JavaScript code. For example, if the user is having fun, the code will be generated to include colors and design elements that match that emotion.

[1413] Step 9: The server outputs the generated program code to the user terminal.

[1414] The server packages the generated program code in JSON format and returns it to the user's device as an HTTP response.

[1415] Step 10: The terminal displays the code received from the server.

[1416] The terminal displays the received program code on a user interface, allowing the user to download or copy the code.

[1417] Step 11: The user creates a web page using the code they received.

[1418] Users can incorporate the displayed program code into their own web projects, edit and adjust it as needed, and complete a rich web page.

[1419] These are the specific processing steps of this system, which allows users to quickly and easily create rich web pages without specialized coding skills, and also customize them to suit individual emotions.

[1420] Example 2

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

[1422] Conventional web page generation systems based on document files have difficulty automatically generating designs and content that reflect the user's intentions and emotions, forcing the user to make manual adjustments. Furthermore, they lack the appropriate text extraction and analysis processes that depend on the format and content of the document file, and the process of generating program code that reflects the results. Therefore, there is a need for a system that can solve these issues and enable users to easily generate rich web pages that reflect their emotions.

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

[1424] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for acquiring emotion data from the user's device in real time, means for generating program code based on the extracted text data and the acquired emotion data, and means for outputting the generated program code. This enables users to quickly and easily generate rich web pages that reflect the user's emotions, even if they do not have specialized coding skills.

[1425] A "document file" is a data format such as a PDF or presentation file created by a user.

[1426] "Means for receiving" refers to a mechanism such as an interface or protocol that allows the server to obtain document files created by users.

[1427] "Predetermined formats" refers to specific file formats that the system can support, specifically PDF and presentation files (e.g., PPTX).

[1428] The "verification means" is a function for verifying that the format of the document file received by the server is a predetermined format.

[1429] "Means of analysis and extraction" refers to the techniques and processes required to extract text data from document files and understand their contents.

[1430] "Emotion data" is information about emotions acquired from the user's facial expressions and voice, and includes joy, sadness, surprise, anger, and the like.

[1431] "Means for acquiring data in real time" refers to a technology that uses the user's device (camera or microphone) to instantly analyze the user's current facial expressions and voice, and collects emotional data as a result.

[1432] The "means for generating program code" is a technology that automatically creates web page generation code such as HTML, CSS, and JavaScript based on the extracted text data and acquired emotion data.

[1433] The "means for outputting" is a mechanism for transmitting the generated program code to the user's terminal so that it can be displayed on the browser or downloaded.

[1434] A "machine learning model" is an algorithm or model that learns patterns and predictions from data and performs a specific task (in this case, converting text and emotion data into program code).

[1435] This invention is a system for quickly and easily generating rich web pages using document files created by users. This system has the unique feature of adjusting the design and content of web pages based on the content of the document file as well as the user's emotional information. This system mainly uses the following hardware and software:

[1436] First, a user creates a PDF or presentation file to represent the design of a web page. For example, they create a file called "example.pptx" and upload it to the system. The user then uses an interface (such as a browser-based upload form) to upload the file.

[1437] The server receives the uploaded document file and checks its extension. If the file format is PDF, it uses the pdfminer library to extract text data. On the other hand, if the file format is a presentation file (PPTX), it uses the python-pptx library to extract the text of each slide. For example, to extract text from a PDF file, the following specific process is performed:

[1438] Parse the PDF file using PDFParser from pdfminer.six.

[1439] Use PDFPageInterpreter to extract the text content of each page.

[1440] The server also collects emotion data in real time from the user's device. The emotion data is collected through the user's camera and microphone, and analyzed by the emotion engine. The emotion engine works as follows:

[1441] Facial expression recognition: Image recognition technology is used to extract the features of the user's facial expression and classify their emotions based on this.

[1442] Speech recognition: Analyzes voice data obtained from a microphone and evaluates the tone and rate to determine emotion.

[1443] The server then uses OpenAI's API to generate HTML, CSS, and JavaScript code based on the extracted text and emotion data. For example, if the user expresses joy, the generated web page will incorporate bright colors and animation effects.

[1444] The device receives the generated HTML, CSS, and JavaScript code sent by the server and displays it in the browser, where the user can download and edit the code.

[1445] For example:

[1446] Example 1: Creating a web page from a PDF file

[1447] 1. A user creates a PDF file named "example.pdf" and uploads it to the system.

[1448] 2. The server checks the file format and extracts the text data from the PDF file using the pdfminer library.

[1449] 3. The server uses the emotion engine to recognize the user's emotion of joy.

[1450] 4. The server uses OpenAI's API to generate HTML, CSS, and JavaScript code for a brightly colored web page.

[1451] 5. The terminal will display the generated code in your browser.

[1452] Example prompt:

[1453] "If the user is expressing joy, generate a web page with text extracted from the PDF, a bright key color, and a vibrant layout."

[1454] Example 2: Generating a web page from a presentation file

[1455] 1. A user creates a presentation file named "example.pptx" and uploads it to the system.

[1456] 2. The server checks the file format and extracts the text data from the presentation file using the python-pptx library.

[1457] 3. The server uses the emotion engine to recognize the user's emotion of excitement.

[1458] 4. The server uses OpenAI's API to generate the HTML, CSS, and JavaScript code for the web page, including the dynamic effects.

[1459] 5. The terminal will display the generated code in your browser.

[1460] Example prompt:

[1461] "If your users are excited, generate a web page with the text extracted from the PPTX and incorporate dynamic design with animation effects."

[1462] This system allows users to quickly and easily generate rich web pages without specialized coding skills, and also allows them to customize them according to their emotions.

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

[1464] Step 1: Upload your document files

[1465] The user creates a PDF or presentation file (e.g., "example.pptx") and uploads the file using the system's file upload interface.

[1466] Input: User-created document file

[1467] Output: Document file uploaded to the server

[1468] Step 2: Check the file format

[1469] The server checks the file extension of the uploaded document. If the file format is not PDF or PPTX, it returns an error message to the user. For example, if the file extension is .txt, it displays the message "Unsupported file format."

[1470] Input: Uploaded document file

[1471] Output: File format check result (PDF / PPTX or error message)

[1472] Step 3: Analyze the document file and extract text

[1473] The server extracts the text using the appropriate library depending on the file format.

[1474] For PDF files: Parse the PDF file using PDFParser from pdfminer.six and extract the text content of each page with PDFPageInterpreter.

[1475] For presentation files (PPTX): Use the python-pptx library to read the PPTX file and extract the text of each slide, along with the text styles (font, size, color, etc.) within each slide.

[1476] Input: Document file (PDF or PPTX)

[1477] Output: Extracted text data

[1478] Step 4: Emotion Recognition with the Emotion Engine

[1479] The server acquires the user's emotional data in real time through the device's camera and microphone, and the emotion engine analyzes the acquired data to determine the user's emotions (joy, sadness, surprise, anger, etc.).

[1480] Facial Expression Recognition: Using image recognition technology, the feature points of the user's facial expression are analyzed to classify emotions.

[1481] Speech recognition: Analyzes voice data obtained from the microphone and determines emotions from the tone and speed of the voice.

[1482] Input: Real-time data from camera and microphone

[1483] Output: User emotion data

[1484] Step 5: Generate code for the web page

[1485] The server uses OpenAI's API to generate HTML, CSS, and JavaScript code based on the extracted text data and acquired emotion data.

[1486] Emotional design elements: For example, if the user is expressing the emotion of joy, incorporate bright colors and animated designs.

[1487] Use of generative AI models: Generate prompts based on text and emotion data, and input them into OpenAI's API to generate program code.

[1488] Input: Text data, emotion data, prompt sentence

[1489] Output: Generated HTML, CSS, and JavaScript code

[1490] Step 6: Outputting the generated code

[1491] The device receives the generated HTML, CSS, and JavaScript code sent from the server and displays it in the browser. The user can download and edit this code, allowing for final confirmation and correction of the generated web page.

[1492] Input: Generated HTML, CSS, and JavaScript code

[1493] Output: Web page displayed in browser, and downloadable program code

[1494] (Application example 2)

[1495] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1496] Conventional web page generation systems using document files were unable to adjust design and content to take user emotions into account, and could only provide generic designs. Furthermore, it was difficult to display promotional content that responded to customer emotions in real time, especially in brick-and-mortar stores. This led to the problem of being unable to implement effective marketing that responded to customer emotions.

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

[1498] In this invention, the server includes means for receiving a document file created by a user, means for verifying that the received document file is in a predetermined format, means for analyzing and extracting text data from the document file, means for generating program code based on the extracted text data and user emotion data, and means for displaying the generated program code in real time on a display device in the requesting store. This allows users to utilize emotion recognition technology to display rich web pages and promotional content in real time in physical stores in response to customer emotions.

[1499] "User" means a person who uses this system to upload document files or use generated codes.

[1500] A "Document File" is a PDF or presentation format file that contains content created by a user.

[1501] The "means for receiving" is a means for uploading a document file created by a user to the system.

[1502] "Specified format" refers to a PDF or presentation format file that the system can handle.

[1503] The "verification means" is a means for checking whether the received document file is in a predetermined format.

[1504] The "means for analyzing and extracting" is a means for analyzing text data from a document file and extracting necessary information.

[1505] "Emotion data" refers to emotional information obtained by analyzing the user's facial expressions and voice.

[1506] The "means for generating program code" refers to a means for generating code such as HTML, CSS, or JavaScript based on the extracted text data and user emotion data.

[1507] The "display device in the requesting store" refers to a video display device such as a display, screen, or smart glasses installed in a physical store.

[1508] The "means for displaying in real time" refers to a means for immediately displaying the generated program code on a display device in the requesting store.

[1509] A "generative AI model" is an AI technology used to generate program code from text data and emotion data using machine learning techniques.

[1510] This invention relates to a system that uses document files created by users to display rich web pages and promotional content in real time on display devices in physical stores. This system has the unique feature of adjusting the design and content based on the content of the document file as well as the user's emotional data. The configuration and operation of this system are described in detail below.

[1511] The system consists of the following main steps:

[1512] 1. Receiving document files

[1513] A user creates a PDF or presentation file (PPTX) to represent the design of a web page or promotional content, and uploads it to the system. For example, a file named "promotion.pptx" is created. The user then uses the interface to upload the created file to the system.

[1514] 2. Check the file format

[1515] The server checks the extension of the received file to ensure it is a supported format (PDF or presentation file), allowing for proper control over the file formats that are processed.

[1516] 3. Document file analysis and text extraction

[1517] The server extracts the text data using the appropriate library depending on the file format (pdfminer for PDFs, python-pptx for presentation files).

[1518] 4. Emotion Data Recognition

[1519] The server includes an emotion engine that analyzes the user's facial expressions and voice via a camera and microphone to recognize emotion data. This emotion engine recognizes the user's emotions, such as joy, sadness, surprise, and anger, in real time.

[1520] 5. Generating Program Code

[1521] The server uses a generative AI model (e.g., OpenAI's API) to generate HTML, CSS, and JavaScript code based on the extracted text data and the user's recognized emotion data, dynamically adjusting design elements and effects according to the emotion data.

[1522] 6. Output and View the Generated Code

[1523] The generated program code is sent in real time from the server to the display device in the requesting store, which then displays a rich web page or promotional content that reflects the user's emotions.

[1524] As a concrete example, consider a case where a store salesperson creates a presentation for a new product launch in PPTX format and uploads it to the system. The system extracts text from the presentation file and recognizes the emotions of customers visiting the physical store by reading their facial expressions via a camera. For example, if a customer expresses surprise, the system generates a web page with dynamic and vivid effects, which is displayed in real time on in-store displays and on the salesperson's smart glasses. This process allows the store to implement effective promotions that are in line with customer emotions.

[1525] Prompt Sentence Examples

[1526] Generate a HTML / CSS / JS code for a web page with the following content:

[1527] Welcome to the new product launch event! Today's menu is as follows: 1. New product introduction 2. Special promotion 3. Q&A. Make it vibrant and suited to surprise emotion.

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

[1529] Step 1:

[1530] Receive document files created by users

[1531] How it works: A user uploads a PDF or presentation file (PPTX) to the system.

[1532] Input: A user-created document file.

[1533] Output: The document file is saved on the server.

[1534] Step 2:

[1535] Checking the format of the received document file

[1536] What happens: The server checks the file extension and sees if it is in a supported format (PDF or PPTX).

[1537] Input: A document file stored on the server.

[1538] Output: Verification that the file is in a supported format.

[1539] Step 3:

[1540] Analyze and extract text data from document files

[1541] How it works: The server extracts text from PDF files using the pdfminer library, or from PPTX files using the python-pptx library.

[1542] Input: The authenticated document file.

[1543] Output: The extracted text data.

[1544] Step 4:

[1545] Recognizing Emotional Data

[1546] How it works: The server analyzes the user's facial expressions and voice through the camera and microphone, and uses an emotion engine to recognize emotional data.

[1547] Input: User facial and voice data captured by camera and microphone.

[1548] Output: Recognized user emotion data.

[1549] Step 5:

[1550] Generate program code

[1551] How it works: The server uses a generative AI model (e.g., OpenAI's API) to generate HTML, CSS, and JavaScript code based on the extracted text and emotion data.

[1552] Input: Extracted text data and recognized emotion data.

[1553] Output: Generated HTML, CSS, and JavaScript code.

[1554] Step 6:

[1555] Print the generated code

[1556] Operation: The generated program code is sent in real time from the server to the display device in the requesting store.

[1557] Input: Generated HTML, CSS, and JavaScript code.

[1558] Output: Rich web pages and promotional content displayed on display devices within the requested store.

[1559] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

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

[1561] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the robot 414.

[1562] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1563] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1564] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1565] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1566] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1567] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1568] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1569] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1570] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1571] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1572] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1573] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1574] The hardware resource for executing a specific process can be any of the following processors: A CPU is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. A dedicated electrical circuit, such as a field-programmable gate array (FPGA), a programmable logic device (PLD), or an application-specific integrated circuit (ASIC), is a processor with a circuit configuration specifically designed to execute a specific process. Each processor has built-in or connected memory, and uses the memory to execute the specific process.

[1575] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1576] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1577] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1578] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1579] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1580] The following is further disclosed regarding the above embodiment.

[1581] (Claim 1)

[1582] means for receiving a document file created by a user;

[1583] means for verifying that the received document file is in a predetermined format;

[1584] means for analyzing and extracting text data from document files;

[1585] means for generating program code based on the extracted text data;

[1586] means for outputting the generated program code;

[1587] A system including:

[1588] (Claim 2)

[1589] 2. The system of claim 1, wherein the document file is a PDF or a presentation file.

[1590] (Claim 3)

[1591] 10. The system of claim 1, further comprising means for using a machine learning model to convert the parsed text data into program code.

[1592] "Example 1"

[1593] (Claim 1)

[1594] means for receiving a document file created by a user;

[1595] means for verifying that the received document file is in a predetermined format;

[1596] means for analyzing and extracting text data from document files;

[1597] means for using the generative model to generate program code based on the extracted text data;

[1598] means for outputting the generated program code;

[1599] A system including:

[1600] (Claim 2)

[1601] 10. The system of claim 1, wherein the document file is a PDF or an electronic slideshow.

[1602] (Claim 3)

[1603] 10. The system of claim 1, further comprising means for using a generative model to convert parsed text data into program code and using prompt sentences.

[1604] "Application Example 1"

[1605] (Claim 1)

[1606] means for receiving a document file created by a user;

[1607] means for verifying that the received document file is in a predetermined format;

[1608] means for analyzing and extracting text data from document files;

[1609] means for generating program code based on the extracted text data;

[1610] means for outputting the generated program code;

[1611] a means for providing the generated program code to a user through a smartphone application;

[1612] A system including:

[1613] (Claim 2)

[1614] 2. The system of claim 1, wherein the document file is a PDF or a presentation file.

[1615] (Claim 3)

[1616] 10. The system of claim 1, further comprising means for using a machine learning model to convert the parsed text data into program code.

[1617] "Example 2: Combining Emotion Engines"

[1618] (Claim 1)

[1619] means for receiving a document file created by a user;

[1620] means for verifying that the received document file is in a predetermined format;

[1621] means for analyzing and extracting text data from document files;

[1622] means for acquiring emotion data in real time from a user's device;

[1623] means for generating a program code based on the extracted text data and the acquired emotion data;

[1624] means for outputting the generated program code;

[1625] A system including:

[1626] (Claim 2)

[1627] 2. The system of claim 1, wherein the document file is a PDF or a presentation file.

[1628] (Claim 3)

[1629] 10. The system of claim 1, further comprising means for using machine learning models to convert the parsed text data and the obtained emotion data into program code.

[1630] "Application example 2 when combining emotion engines"

[1631] (Claim 1)

[1632] means for receiving a document file created by a user;

[1633] means for verifying that the received document file is in a predetermined format;

[1634] means for analyzing and extracting text data from document files;

[1635] means for generating program code based on the extracted text data;

[1636] means for generating a program code based on the extracted text data and the user's emotion data;

[1637] means for outputting the generated program code;

[1638] a means for displaying the generated program code in real time on a display device in the requesting store;

[1639] A system including:

[1640] (Claim 2)

[1641] 2. The system of claim 1, wherein the document file is a PDF or a presentation file.

[1642] (Claim 3)

[1643] 10. The system of claim 1, further comprising means for using a generative AI model to convert the parsed text data and user emotion data into program code. [Explanation of symbols]

[1644] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. means for receiving a document file created by a user; means for verifying that the received document file is in a predetermined format; means for analyzing and extracting text data from document files; means for generating program code based on the extracted text data; means for outputting the generated program code; A system including:

2. 2. The system of claim 1, wherein the document file is a PDF or a presentation file.

3. 10. The system of claim 1, further comprising means for using a machine learning model to convert the parsed text data into program code.

Images