System

Abstract

A system is provided.SOLUTION: This system is provided with a means for receiving information such as the theme, character setting and plot point of a script from a user, a means for calling a generation model based on the information and generating a new script element, a means for shaping the generated contents into a script format and a means for transmitting the shaped script data to the terminal of the user.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] The traditional scriptwriting process requires screenwriters to expend a significant amount of time and effort, making it particularly difficult to generate original dialogue and plot points. Furthermore, market saturation and clichés are a risk, making it necessary to efficiently create high-quality scripts. The present invention aims to solve these problems and enable screenwriters to create scripts in a more efficient and innovative way. [Means for solving the problem]

[0005] The present invention solves the above-mentioned problems by providing a system that includes: means for receiving information such as themes, character settings, and plot points of a script from a user; means for invoking a generative model based on the information to generate new script elements; means for formatting the generated content into a script; and means for transmitting the formatted script data to a user's terminal. In particular, the generative model of the present invention is capable of generating dialogue, plot points, and character development, and also has the function of verifying the information data and checking for missing information or invalid formatting. This significantly improves the efficiency of the scriptwriting process while improving the quality of the script.

[0006] "User" means an individual or organization that uses the system to provide information such as themes, character settings, and plot points of a script.

[0007] "Theme" refers to the central subject or genre that a script deals with.

[0008] "Character settings" are detailed information about the roles, characteristics, backgrounds, etc. of the characters who appear in the script.

[0009] A "plot point" is an event or element that plays an important role in the progression or development of a story.

[0010] A "generative model" is an algorithm or AI system that automatically generates new dialogue, plot points, character development, etc. based on input information.

[0011] "Screenplay elements" are the individual components of a screenplay, such as dialogue, plot points, and character development.

[0012] "Formatting" is the process of organizing the generated content into a script format to make it easier to read.

[0013] "Script data" is formalized script information obtained by formatting the dialogue and plot points generated by the generative model.

[0014] A "terminal" is a device that allows a user to access the system and confirm input and generated results.

[0015] "Validation" is the process of verifying that the data received is accurate and valid.

[0016] "Generation" is the process of automatically creating new script elements based on the information provided. [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 invention is a system that receives information such as themes, character settings, and plot points of a script provided by the user, and generates new script elements using a generative model based on that information, thereby supporting efficient and creative scriptwriting.

[0039] Server Operation

[0040] The server plays a central role and performs the following main tasks:

[0041] 1. Receiving and Validating a Request

[0042] The server receives a request sent by a user. This request contains information such as the theme, character settings, and plot points of the script. The server first checks whether this data is valid. For example, if the theme or character information is missing, it returns an error message.

[0043] 2. Invoking the Generative Model

[0044] After receiving valid data, the server invokes a generative model (e.g., a machine learning model or AI algorithm) to generate new script elements. The model automatically creates dialogue, plot points, character development, etc. based on the information provided.

[0045] 3. Formatting Content

[0046] The generated script elements are in raw text format, so the server formats them into a script, specifically by organizing the content according to the format of scene descriptions, dialogues, character introductions, etc.

[0047] 4. Sending the Response

[0048] The formatted script data is returned to the user. Specifically, the generated results are sent to the user's device via an HTTP response or WebSocket.

[0049] Device behavior

[0050] The terminal provides the user interface and is responsible for the following:

[0051] 1. Getting User Input

[0052] The terminal collects input from the user about the script's theme, character settings, plot points, etc. This input is done through a GUI.

[0053] 2. Submitting a Request

[0054] The acquired input data is sent to the server. The terminal generates an HTTP request and sends it to the server, including the necessary parameters.

[0055] 3. Receiving and Displaying Responses

[0056] It receives the generated results from the server and displays them to the user, providing an interface for the user to edit and modify the displayed data.

[0057] User behavior

[0058] The user performs the following actions:

[0059] 1. Provision of information

[0060] Users input information about the script's theme, character settings, plot points, etc. For example, when creating a sci-fi script, they input information about the character, such as "Taro Tanaka, engineer, brave and intelligent."

[0061] 2. Sending a generation request

[0062] The user submits a generation request based on the information they entered. By pressing the "Generate" button, this information is sent to the server.

[0063] 3. Check and edit the results

[0064] Review the generated script data and edit it as needed, fine-tuning dialogue and plot points to complete the final script.

[0065] Specific examples

[0066] Below are some specific usage examples.

[0067] 1. The user selects "SF" as the theme of the script and enters "Taro Tanaka, engineer, brave and intelligent" as the character setting.

[0068] 2. The device sends this information to the server.

[0069] 3. The server verifies the information and calls the generative model to generate script elements such as:

[0070] Taro Tanaka: "Our mission is to repair the space station. We don't have much time, so hurry!"

[0071] Plot Point: A space station is severely damaged by a meteorite impact, requiring emergency repairs.

[0072] 4. The server formats the generated content, converts it into a script format, and sends it to the terminal.

[0073] 5. The terminal displays the generated results to the user, who can then check and edit them.

[0074] In this way, screenwriters can easily and efficiently generate high-quality scripts, allowing them to focus on their creative work.

[0075] The processing flow will be explained below.

[0076] Server Processing

[0077] Step 1:

[0078] The server receives requests from users via HTTP requests or WebSockets, which contain information such as the script's theme, character settings, and plot points.

[0079] Step 2:

[0080] The server validates the data it receives, checking that it is valid and contains all the required information, and returns an error message to the user if any data is missing or invalid.

[0081] Step 3:

[0082] With the data successfully validated, the server invokes a generative model, which then inputs this data into the model to generate new script dialogue, plot points, character development, etc.

[0083] Step 4:

[0084] The server formats the raw text returned by the generative model into a screenplay, specifically by organizing the content according to formats such as scene descriptions, dialogues, and character introductions.

[0085] Step 5:

[0086] The formatted script data is sent to the user's device as an HTTP response or WebSocket message.

[0087] Terminal handling

[0088] Step 1:

[0089] The terminal takes input from the user through a GUI, such as the screenplay's theme, character settings, and plot points. This information is entered using forms and select boxes.

[0090] Step 2:

[0091] The device sends the acquired data to the server in the form of an HTTP request. The device sets the necessary headers and parameters and sends the data using the POST method.

[0092] Step 3:

[0093] The terminal receives a response sent from the server, which includes the generated script data.

[0094] Step 4:

[0095] Presents the received script data to the user through a user interface, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[0096] User Action

[0097] Step 1:

[0098] The user inputs information about the script, such as the theme, character settings, and plot points, into the terminal. For example, a sci-fi theme setting and character details can be entered.

[0099] Step 2:

[0100] By pressing the "Generate" button, the user sends a generation request to the server based on the information entered.

[0101] Step 3:

[0102] The user confirms the generated results returned from the server, checks the script data displayed on the terminal, and makes edits or corrections as necessary.

[0103] Step 4:

[0104] Users can save or export their edited script, select the file format and destination, and complete the final script.

[0105] This series of steps allows the user, terminal, and server processes to work together and the script creation process to proceed smoothly.

[0106] Example 1

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

[0108] In conventional scenario creation, manually setting themes, characters, and constructing stories requires time and effort, limiting the scope for creativity. Furthermore, efficient scenario creation is difficult because there is no established method for formatting the generated scenario elements and effectively providing them to users.

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

[0110] In this invention, the server includes means for receiving data such as the scenario theme, character settings, and story main points from the user, means for calling a generation algorithm based on the data to generate new scenario elements, means for formatting the generated content into a scenario format, and means for transmitting the formatted scenario data to the user's device. This enables the efficient generation of high-quality, creative scenarios.

[0111] 1. "User" refers to a person or organization that uses the system to provide data such as the scenario's theme, character settings, and story key points.

[0112] 2. A "scenario" is the overall structure of a story that combines the story's theme, character settings, plot points, etc.

[0113] 3. "Theme" is a concept that indicates the central subject, genre, or setting of a story.

[0114] 4. A "character" is a character who has a specific role within the scenario.

[0115] 5. A "story point" is a point that indicates an important event or development in a story.

[0116] 6. "Data" refers to information received by the system, such as themes, character settings, and story points.

[0117] 7. "Generative Algorithm" refers to artificial intelligence techniques or machine learning models that generate new scenario elements based on provided data.

[0118] 8. "Scenario Elements" are the individual parts that make up a scenario, such as generated dialogue, plot points, character development, etc.

[0119] 9. "Formatting" refers to the process of organizing and converting the generated scenario elements into an appropriate scenario format.

[0120] 10. "Device" means an electronic device, such as a computer, smartphone, or tablet, that a User uses to access the System.

[0121] This invention is a system that receives data such as the scenario theme, character settings, and story key points provided by the user, and uses a generation algorithm to generate new scenario elements based on that data, thereby supporting efficient and creative scenario creation.

[0122] Server Operation

[0123] The server plays a central role and performs the following main tasks:

[0124] 1. Receiving and validating data from the user

[0125] The server receives a request sent by the user. This request contains data such as the scenario's theme, character settings, and story summary. The server first checks whether this data is valid. For example, if the theme or character information is missing, it returns an error message.

[0126] 2. Invoking the generation algorithm

[0127] After receiving valid data, the server invokes a generative algorithm (e.g., an AI technology such as GPT-4) to generate new scenario elements. The algorithm automatically creates dialogue, story points, character development, etc. based on the provided data.

[0128] 3. Formatting the generated data

[0129] The generated scenario elements are in raw text format, so the server formats them into an appropriate scenario format, specifically by arranging and converting the content according to the format of scene descriptions, dialogues, character introductions, etc.

[0130] 4. Sending formatted data

[0131] The formatted scenario data is returned to the user's device. Specifically, the generated results are sent to the user's device using protocols such as HTTP responses or WebSockets.

[0132] Device behavior

[0133] The terminal provides a user interface and is responsible for the following processes:

[0134] 1. Getting User Input

[0135] The terminal collects input from the user about the scenario's theme, character settings, storyline, etc. This input is done through a GUI.

[0136] 2. Submitting a Request

[0137] The acquired data is sent to the server. The device generates an HTTP request and sends it to the server, including the necessary parameters.

[0138] 3. Receiving and Displaying Responses

[0139] It receives the generated results from the server and displays them to the user, providing an interface for the user to edit and modify the displayed data.

[0140] User behavior

[0141] The user performs the following actions:

[0142] 1. Provision of information

[0143] Users input data into the system, such as the scenario's theme, character settings, main points of the story, etc. For example, when creating a science fiction scenario, users might input information such as "engineer, brave, and intelligent" for the characters.

[0144] 2. Sending a generation request

[0145] The user submits a generation request based on the information they entered. By pressing the "Generate" button, this data is sent to the server.

[0146] 3. Check and edit the results

[0147] Check the generated scenario data and edit it as necessary, fine-tuning the dialogue and key points of the story to complete the final scenario.

[0148] Specific examples

[0149] Example

[0150] 1. The user selects "science fiction" as the scenario theme and enters "engineer, brave and intelligent" as the character description.

[0151] 2. The user enters the main point of the story: "A space station is severely damaged by a meteorite impact, requiring emergency repairs."

[0152] 3. The device sends this data to the server.

[0153] 4. The server validates the data and invokes a generation algorithm to generate the following scenario elements:

[0154] Character: "Our mission is to repair the space station. We don't have much time, we have to hurry!"

[0155] Scene description: A space station is severely damaged by a meteorite impact, requiring emergency repairs.

[0156] 5. The server formats the generated content, converts it into a scenario format, and sends it to the terminal.

[0157] 6. The terminal displays the generated results to the user, who can then check and edit them.

[0158] Prompt Sentence Examples

[0159] Theme: Sci-Fi

[0160] Character Profile: Engineer, brave and intelligent

[0161] Summary: A space station is destroyed by a meteorite and requires emergency repairs.

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

[0163] Program processing steps

[0164] Step 1: Collecting User Input

[0165] User behavior

[0166] Through the system's interface, users input data such as the scenario's theme, character settings, and story key points. For example, they can select "science fiction" as the theme, provide "engineer, brave and intelligent" as the character settings, and provide "a space station is destroyed by a meteorite impact and requires emergency repairs" as the story key point.

[0167] input

[0168] The scenario's theme, character settings, and main points of the story.

[0169] output

[0170] Collected user input data.

[0171] Specific actions

[0172] The user enters data into the input fields and clicks the Submit button.

[0173] Step 2: Submitting the request

[0174] Device behavior

[0175] The device sends the data collected from the user to the server as an HTTP request. Specifically, it converts the input data into JSON format and sends it to the server.

[0176] input

[0177] Collected user input data.

[0178] output

[0179] An HTTP request to the server.

[0180] Specific actions

[0181] The terminal generates data in JSON format and sends the data to the server using the HTTP protocol.

[0182] Step 3: Receiving and validating the request

[0183] Server Operation

[0184] The server receives an HTTP request sent by a user. It validates the data contained in the request (theme, character setting, storyline) to ensure it is valid. If any information is missing or invalid, the server generates an error message and sends it to the terminal.

[0185] input

[0186] HTTP request from the user.

[0187] output

[0188] Data that passes validation, or an error message.

[0189] Specific actions

[0190] The server parses the data and performs validation processing.

[0191] Step 4: Invoke the generation algorithm

[0192] Server Operation

[0193] The server then invokes a generation algorithm (e.g., AI technology such as GPT-4) based on the validated data, which generates new scenario elements (dialogue, story points, character development) based on the provided data.

[0194] input

[0195] Data that passed validation.

[0196] output

[0197] Generated scenario elements (dialogue, story points, character development).

[0198] Specific actions

[0199] The server invokes the generation algorithm to generate scenario elements.

[0200] Step 5: Formatting the generated data

[0201] Server Operation

[0202] The server then formats the generated scenario elements into an appropriate scenario format, specifically by arranging and converting the content according to the format of scene descriptions, dialogues, character introductions, etc.

[0203] input

[0204] Generated scenario elements.

[0205] output

[0206] Scenario data formatted in scenario format.

[0207] Specific actions

[0208] The server converts the content into a scenario format and generates formatted data.

[0209] Step 6: Sending formatted data

[0210] Server Operation

[0211] The server sends the formatted scenario data to the user's device. Specifically, it sends the formatted data to the terminal as an HTTP response.

[0212] input

[0213] Scenario data formatted in scenario format.

[0214] output

[0215] The HTTP response to the user's device.

[0216] Specific actions

[0217] The server generates an HTTP response and sends the formatted data.

[0218] Step 7: Review and edit the results

[0219] Device behavior

[0220] The terminal receives the generated results from the server and displays them to the user. The user can check the generated scenario data and edit it as necessary. The user can adjust the dialogue and story points through the interface.

[0221] input

[0222] Generated scenario data received from the server.

[0223] output

[0224] Scenario data displayed to the user, and the results of editing by the user.

[0225] Specific actions

[0226] The terminal analyzes and displays the received data, and the user performs editing operations.

[0227] (Application example 1)

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

[0229] In recent years, the demand for scriptwriting has increased, creating a need for high-quality scripts to be written quickly and efficiently. However, traditional methods require scriptwriters to expend a great deal of time and effort, which can be particularly burdensome when themes, character settings, and plot points are complex. Furthermore, the editing process after script generation is cumbersome, making it difficult to achieve an efficient workflow. To solve these issues, a system that can provide consistent support from script generation to editing is needed.

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

[0231] In this invention, the server includes means for receiving information such as the script theme, character settings, and plot points from the user, means for calling a generative model based on the information and generating new script elements, means for formatting the generated content into a script format, means for transmitting the formatted script data to the user's terminal, and display means for the user to check and edit the generated script data. This allows users to easily generate high-quality scripts and further edit the generated script in real time through an interface. Furthermore, the use of a cloud server allows for rapid large-scale data processing, providing users with a seamless experience.

[0232] A "theme" refers to the main subject or specific content of a script, the central idea that influences the progression of the story.

[0233] "Character settings" include detailed information about the personalities, backgrounds, roles, etc. of the characters who appear in the script.

[0234] A "plot point" is an element that is an important event or turning point in the progression of a story, and forms the basis for the story's development.

[0235] A "generative model" refers to an algorithm or system that uses machine learning or artificial intelligence to automatically generate new script elements based on user-provided information.

[0236] "Script format" refers to the format in which the generated content is organized according to the format of scene descriptions, dialogue, character introductions, etc.

[0237] A "cloud server" refers to a remote server that can be accessed via the Internet and provides large-scale data processing and storage functions.

[0238] "User's terminal" refers to a computer, smartphone, tablet, etc. used by a user, which is a device for receiving and displaying generated script data.

[0239] "Display means" refers to an interface that allows a user to visually check and edit the generated script data.

[0240] "Data validation" is the step where we check whether the information provided by the user is missing or in an invalid format and take appropriate action.

[0241] "Means for making it editable" refers to the ability for users to modify and fine-tune the generated script as needed.

[0242] This invention is a system that receives information such as the theme, character settings, and plot points of a script provided by a user, and generates new script elements using a generative model based on that information. Specific embodiments are described below.

[0243] Server Operation

[0244] The server plays a central role in this system and performs the following main processes:

[0245] 1. Receiving and validating a request:

[0246] The server receives a request sent by a user using the HTTPS protocol. This request contains information such as the script's theme, character settings, and plot points. The server first checks whether this data is valid. For example, if the theme or character information is missing, it returns an error message.

[0247] 2. Invoke the generative model:

[0248] Given valid data, the server invokes a generative model (e.g., a generative AI model like GPT-4) to generate new script elements, such as dialogue, plot points, and character development, automatically based on the information provided.

[0249] 3. Formatting content:

[0250] The generated script elements are in raw text format, so the server formats them into a script, specifically by organizing the content according to the format of scene descriptions, dialogues, character introductions, etc.

[0251] 4. Sending the response:

[0252] The formatted script data is sent to the user's device. Specifically, the generated results are sent to the user's device via HTTP response or WebSocket.

[0253] Device behavior

[0254] The terminal provides the user interface and is responsible for the following:

[0255] 1. Getting user input:

[0256] The terminal collects input from the user about the script's theme, character settings, plot points, etc. This input is done through a GUI.

[0257] 2. Submit your request:

[0258] The acquired input data is sent to the server. The terminal generates an HTTPS request and sends it to the server, including the necessary parameters.

[0259] 3. Receiving and Displaying Responses:

[0260] It receives the generated results from the server and displays them to the user, providing an interface for the user to edit and modify the displayed data.

[0261] User behavior

[0262] The user performs the following actions:

[0263] 1. Provision of information:

[0264] Users input information about the script's theme, character settings, plot points, etc. For example, if creating a sci-fi script, they input information about the character, such as "engineer, brave, and intelligent."

[0265] 2. Send the generation request:

[0266] The user submits a generation request based on the information they entered. By pressing the "Generate" button, this information is sent to the server.

[0267] 3. Review and edit the results:

[0268] Review the generated script data and edit it as needed, fine-tuning dialogue and plot points to complete the final script.

[0269] Specific examples

[0270] Let's consider a specific example of a movie production company using this system. The theme is "Tokyo of the future," the character is a "police officer of the future with a very keen intuition," and the plot point is a "mysterious disappearance." The following prompt is sent to the generative AI model:

[0271] Example prompt sentence:

[0272] Theme: Future Tokyo

[0273] Character: A police officer from the future with a keen intuition

[0274] Plot Point: Mysterious Disappearance

[0275] Generated script elements please.

[0276] As described above, this invention allows users to easily generate high-quality scripts and then edit the generated scripts in real time through an interface. Furthermore, by using a cloud server, large-scale data processing can be performed quickly, providing users with a seamless experience.

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

[0278] Step 1:

[0279] The user inputs information such as the script's theme, character settings, and plot points through the device's user interface. This information is collected as input data. The input includes specific details such as the theme being "Tokyo of the future," the character setting being "a police officer of the future with a very keen intuition," and the plot point being "a mysterious disappearance."

[0280] Step 2:

[0281] The device sends the collected input data to the server as an HTTPS request, which includes the user's input such as theme, character settings, and plot points.

[0282] Step 3:

[0283] The server validates the data of the received request. This validation process checks whether the data is complete and not invalid. For example, if character information is missing, an error message is generated and returned to the user. The input of this step is the input data from the user, and the output is the validation result.

[0284] Step 4:

[0285] Once valid data is verified, the server invokes a generative AI model (e.g., GPT-4). The generative AI model generates new script elements based on the provided theme, character settings, and plot points. The input is the validated data, and the output is the generated script elements. For example, a script element might be generated such as "A police officer from the future investigates a mysterious disappearance in Tokyo."

[0286] Step 5:

[0287] The generated script elements are returned to the server in raw text format, which the server then formats into a user-friendly script. Specifically, the script is organized according to the format of scene descriptions, dialogues, character introductions, etc. The input of this step is the generated raw text, and the output is formatted script data.

[0288] Step 6:

[0289] The server generates an HTTP response to send the formatted script data to the user's terminal. This response is used as a display means for the user to check and edit. The input is the formatted script data, and the output is the data to be sent to the user's terminal.

[0290] Step 7:

[0291] The terminal displays the script data received from the server. The user reviews this data and makes edits as needed, for example, fine-tuning the dialogue in the generated script or adding plot points. The input is the data received from the server, and the output is the data displayed and edited in the user interface.

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

[0293] This invention is a system that uses a generative model to generate new script elements based on information provided by the user, such as the script's theme, character settings, and plot points, and also combines it with an emotion engine that recognizes the user's emotions and customizes the script content, making it possible to generate more personalized scripts.

[0294] Server Operation

[0295] The server receives a request from the user and performs the following process:

[0296] 1. Receiving and Validating a Request

[0297] The server receives information about the script submitted by the user, such as themes, characterization, plot points, etc. It also checks that the received data is valid and contains all the required information, and returns an error message to the user if any data is missing or invalid.

[0298] 2. Emotion engine activation and analysis

[0299] The server activates an emotion engine and analyzes the user's input data and user interface operation history to recognize the user's emotions, such as the speed at which the text is entered, the content of the input, and the frequency and strength of clicks.

[0300] 3. Invoking the Generative Model

[0301] Based on the recognized emotions, a generative model is invoked, which generates customized dialogue, plot points, character development, etc. based on the user's emotions and the information provided.

[0302] 4. Content Formatting

[0303] The generated script elements are formatted into a script according to the format of scene descriptions, dialogues, character introductions, etc.

[0304] 5. Sending the Response

[0305] The formatted script data is sent to the user's device. The generated script is customized based on the user's emotions, resulting in a more personalized content.

[0306] Device behavior

[0307] The terminal provides a user interface and performs the following processes:

[0308] 1. Getting User Input

[0309] The device gets input from the user about the screenplay's themes, characterization, plot points, etc. For example, it uses forms and select boxes to collect information.

[0310] 2. Collecting Emotional Data

[0311] The device collects data such as the user's typing speed, text content, and click frequency, and passes this information to an emotion engine, which analyzes the user's emotions in real time.

[0312] 3. Submitting a Request

[0313] The acquired input data and emotion data are sent to the server as an HTTP request.

[0314] 4. Receiving and Displaying Responses

[0315] Receives customized script data sent from the server and displays it to the user, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[0316] User Actions

[0317] The user performs the following operations:

[0318] 1. Provision of information

[0319] The user inputs information about the script, such as the theme, character settings, and plot points, into the system. For example, the user inputs a sci-fi theme setting and character details.

[0320] 2. Submitting a Request

[0321] By pressing the "Generate" button, the user sends a generation request to the server based on the input information and the emotion data collected by the device.

[0322] 3. Check and edit the results

[0323] Review the customized script data and make edits and revisions as needed, fine-tuning dialogue, plot points, etc., to complete the final script.

[0324] Specific examples

[0325] As a concrete use case, consider a user writing a science fiction-themed screenplay. The user enters the following information:

[0326] Theme: Sci-Fi

[0327] Character Description: "Taro Tanaka, engineer, brave and intelligent"

[0328] Plot Point: "A space station is severely damaged by a meteorite impact and requires emergency repairs."

[0329] While the user is typing, the emotion engine analyzes their typing speed and click strength to determine if they are impatient. The server then uses a generative model to generate a script that reflects the user's emotions. For example, the tone of the dialogue may be adjusted to create a more tense atmosphere.

[0330] The generated script looks like this:

[0331] Taro Tanaka: "Our mission is to repair the space station. We don't have much time, so hurry!"

[0332] Finally, the server formats the customized script and sends it to the user's device, where the user can review and edit it to complete the final script.

[0333] In this way, by combining emotion engines, more personalized script generation based on the user's emotions can be achieved.

[0334] The processing flow will be explained below.

[0335] Server Processing

[0336] Step 1:

[0337] The server receives requests from users via HTTP requests, WebSockets, etc. The requests contain information such as the script's theme, character settings, and plot points.

[0338] Step 2:

[0339] The server validates the received data, checking whether enough theme and character information has been provided or if any information is missing, and returns an error message to the user if any data is missing or invalid.

[0340] Step 3:

[0341] The server activates an emotion engine and analyzes the user's input data and the user interface operation history to recognize the user's emotion, such as input speed, input content, click frequency and intensity, etc.

[0342] Step 4:

[0343] Based on the emotion data recognized by the emotion engine, a generative model is invoked, which generates new script elements (dialogue, plot points, character development, etc.) based on the user's emotions and the information provided.

[0344] Step 5:

[0345] The generated content is formatted into a script, specifically by organizing the content according to a format such as scene descriptions, dialogue, and character introductions.

[0346] Step 6:

[0347] The formatted script data is sent to the user's device as an HTTP response or WebSocket message.

[0348] Terminal handling

[0349] Step 1:

[0350] The terminal receives input from the user through a GUI, such as the script's theme, character settings, and plot points. The input is collected using forms and select boxes.

[0351] Step 2:

[0352] The device collects data such as the user's typing speed, text content, and click frequency and intensity, and passes this data to the emotion engine. This data is collected in real time as you type.

[0353] Step 3:

[0354] The acquired input data and emotion data are sent to the server in the form of an HTTP request, with appropriate headers and parameters set.

[0355] Step 4:

[0356] The terminal receives the response sent from the server, which includes the generated customized script data.

[0357] Step 5:

[0358] Presents the received script data to the user through a user interface, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[0359] User behavior

[0360] Step 1:

[0361] The user inputs information about the script, such as the theme, character settings, and plot points, into the terminal. For example, the user inputs a sci-fi theme or character details.

[0362] Step 2:

[0363] The user presses the "Generate" button to send a generation request to the server based on the input information and the emotion data collected by the device.

[0364] Step 3:

[0365] The user confirms the customized script data returned from the server, checks the script data displayed on the terminal, and makes edits or corrections as necessary.

[0366] Step 4:

[0367] Users can save or export their edited script, select the file format and destination, and complete the final script.

[0368] This series of steps allows the user, device, and server processes to work together to smoothly advance the script generation process. Customization based on the user's emotions results in a more personalized script.

[0369] Example 2

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

[0371] Conventional script generation systems were able to generate and format script elements based on information received from users, but they were unable to generate personalized scripts that took the user's emotions into account. Because they were unable to create dialogue or set scenes that reflected the user's emotions, it was difficult to create a script that reflected each individual's emotions and intentions during the creative process.

[0372] The specific processing by the specific processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes means for receiving information such as the theme, character settings, and plot points of the script from the user, means for calling a generative model based on the information and generating new script elements, means for formatting the generated content into a script format, means for sending the formatted script data to the user's terminal, means for activating an emotion engine that recognizes the user's emotions and analyzing the user's input data and operation history, and means for customizing the generative model based on the recognized emotions. This makes it possible to generate a script personalized according to the user's emotions.

[0373] A "user" is an entity that uses the system to provide information such as the theme, character settings, and plot points of a script and receives the generated script.

[0374] A "server" is a computer device that receives requests from users and performs a series of processes such as generating, formatting, and transmitting a script.

[0375] "Theme" is information that defines the basic subject matter and genre of the entire script.

[0376] "Character settings" are information that defines the detailed characteristics and roles of the characters that appear in the script.

[0377] A "plot point" is information that indicates an important event or turning point in the progression of a script.

[0378] A "generative model" is an algorithm or program for generating new script elements based on user-provided information.

[0379] "Script elements" are various pieces of content such as dialogue, scene descriptions, and character details that are generated by a generative model.

[0380] An "emotion engine" is a software component that analyzes a user's input data and operation history to recognize emotions.

[0381] "Emotional data" is information such as typing speed, click frequency, and content that is collected to reflect a user's emotions.

[0382] "Formatting" is the process of organizing the generated script elements into a format such as scene descriptions, dialogue, and character introductions.

[0383] An "HTTP request" is a communication format that follows a protocol for sending information from a user's terminal to a server.

[0384] A "prompt sentence" is data in the form of a specific document that is input to a generative model.

[0385] This invention relates to a system that generates new script elements based on information such as themes, character settings, and plot points of a script provided by a user, and also recognizes the user's emotions to personalize the script content. Specific methods for implementing this system are described below.

[0386] Server Operation

[0387] The server uses several software components to process the script generation. First, the server receives the HTTP request sent by the user. This request contains information about the script's theme, character settings, plot points, etc. The server validates the received information to ensure that all required data is present.

[0388] Next, the server launches the emotion engine, which uses a software library called "EmotionalAnalyzer.dll" to analyze the user's input data and operation history (input speed, click frequency, etc.) to recognize the user's emotions. This allows the server to understand the user's emotional state, such as whether they are anxious or relaxed.

[0389] The server then invokes the generative AI model, implemented in the file "ScriptGenerator.ai," which takes emotion data and user-provided data in the form of a prompt. For example, it generates the following prompt:

[0390] "Theme: Sci-Fi, Character: Tanaka Taro, engineer, brave and intelligent, Plot point: A space station is destroyed by a meteorite and requires emergency repairs. Generate tense dialogue that takes into account the user's impatience."

[0391] The generative AI model generates new script elements based on this prompt.

[0392] The generated script elements are formatted into a script using "ScriptFormatter.dll", for example, into scene descriptions, dialogues, character introductions, etc.

[0393] Finally, the formatted script data is sent to the user's device as an HTTP response.

[0394] Device behavior

[0395] The terminal provides a user interface and takes input from the user about the screenplay's theme, character settings, plot points, etc. This input is done through forms and select boxes and stored in a variable, for example "themeInput.value".

[0396] In addition, the device collects data such as the user's typing speed and click frequency in real time and converts it into a format that can be passed to the emotion engine, allowing the server to recognize the user's emotions.

[0397] When the user completes all input and clicks the "Generate" button, the device sends the input data and emotion data to the server as a single HTTP request.

[0398] After receiving the HTTP response from the server, the device displays the received script data to the user in an appropriate format. For example, the dialogue portion is displayed as "quoteElement.innerHTML".

[0399] User Actions

[0400] The user inputs information about the script, such as the theme, character settings, and plot points of the script into the system. For example, they input a sci-fi theme and character details. After completing all the input, the user clicks the "Generate" button to send the request to the server.

[0401] The generated script data is reviewed and, if necessary, the dialogue, scenes, etc. are edited. Finally, the user creates a completed script using a tool such as a text editor.

[0402] In this way, by combining emotion engines, more personalized script generation based on the user's emotions can be achieved.

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

[0404] Step 1:

[0405] Receiving and Validating a Request

[0406] 1. The server receives an HTTP request sent by the user.

[0407] Input: An HTTP request containing information about the screenplay's theme, characterization, plot points, etc.

[0408] Output: Various extracted information.

[0409] 2. The server extracts the received data and checks for missing information or invalid formats.

[0410] Data processing: Checking themes and character settings, and validating that all necessary information is available.

[0411] Behavior: If validation fails, an error message is generated and returned to the user.

[0412] Step 2:

[0413] Emotion engine activation and analysis

[0414] 1. The server starts the emotion engine.

[0415] Input: Extracted user input data and operation history (typing speed, click frequency, etc.).

[0416] Output: The user's emotional state.

[0417] 2. The emotion engine analyzes the input data and recognizes the user's emotions.

[0418] Data calculations: Sentiment analysis using text entry speed, click frequency, and input content.

[0419] How it works: The emotion engine uses the data to determine the user's emotional state, such as whether they are anxious.

[0420] Step 3:

[0421] Invoking the generative model

[0422] 1. The server invokes the generative AI model based on the emotions recognized by the emotion engine.

[0423] Input: User emotional data, script themes, characterization, and plot points.

[0424] Output: The newly generated script element.

[0425] 2. The server converts this data into prompt sentence format and inputs it into the generative model.

[0426] Data processing: Prompt sentence generation.

[0427] How it works: The generative AI model generates new script elements based on the prompt. For example, it generates the following prompt:

[0428] "Theme: Sci-Fi, Character: Tanaka Taro, engineer, brave and intelligent, Plot point: A space station is destroyed by a meteorite and requires emergency repairs. Generate tense dialogue that takes into account the user's impatience."

[0429] Step 4:

[0430] Content Formatting

[0431] 1. The server formats the script elements received from the generative model into a script format.

[0432] Input: Generated script elements.

[0433] Output: Formatted script data.

[0434] 2. The server uses "ScriptFormatter.dll" to organize the generated elements into formats such as scene descriptions, dialogues, character introductions, etc.

[0435] Data processing: Formatting various script elements into a specified format.

[0436] Step 5:

[0437] Sending a response

[0438] 1. The server sends the formatted script data to the user's device as an HTTP response.

[0439] Input: Formatted script data.

[0440] Output: The HTTP response sent to the user's device.

[0441] Step 6:

[0442] Getting User Input

[0443] 1. The device obtains information such as theme, character settings, and plot points through the user interface.

[0444] Input: User-supplied themes, characterizations, and plot points.

[0445] Output: User input data stored on the device.

[0446] 2. The device stores the collected data in a variable, for example, "themeInput.value".

[0447] Behavior: Provides input forms and select boxes.

[0448] Step 7:

[0449] Collecting Emotional Data

[0450] 1. The device collects emotional data such as the user's text input speed, click frequency, and input content.

[0451] Input: User operation data.

[0452] Output: Collected emotion data.

[0453] 2. The device converts this data into a format that can be passed to the emotion engine and stores it in variables.

[0454] Step 8:

[0455] Submitting a Request

[0456] 1. The device sends the collected user input data and emotion data together as an HTTP request to the server.

[0457] Input: Collected user input data and sentiment data.

[0458] Output: The HTTP request sent to the server.

[0459] Step 9:

[0460] Receiving and displaying the response

[0461] 1. The terminal receives the HTTP response returned from the server.

[0462] Input: The HTTP response from the server.

[0463] Output: Received script data.

[0464] 2. The terminal displays the received script data in an appropriate format for the user.

[0465] Behavior: The dialogue is displayed as "quoteElement.innerHTML".

[0466] (Application example 2)

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

[0468] Conventional script generation systems have difficulty identifying user emotions and reflecting them in the script content, which has led to the issue of insufficient script generation personalized for each user. Therefore, there is a need for a method to generate scripts that are more individualized and in line with emotions by generating scripts based on the user's emotions.

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

[0470] In this invention, the server includes means for receiving information such as the theme, character settings, and plot points of the script from the user, means for calling a generative model based on the information and generating new script elements, means for formatting the generated content into a script format, means for sending the formatted script data to the user's terminal, means for collecting the user's input speed and click strength, means for analyzing the collected data to recognize the user's emotions, and means for customizing the generative model according to the emotions. This enables more personalized script generation by analyzing the user's emotions in real time and customizing the script content based on that.

[0471] "Means for receiving information from a user about the screenplay's theme, character settings, plot points, etc." refers to a device or software that provides an interface for a user to input the screenplay's theme, character details, and major plot points.

[0472] The "means for invoking a generative model based on the information and generating new script elements" refers to an algorithm or software module for using artificial intelligence to generate new scenario elements based on the acquired user information.

[0473] "Means for formatting the generated content into a script" refers to a device or software that organizes the generated scenario elements, such as dialogue, scene descriptions, and character introductions, according to a standard scenario format and converts them into an appropriate format.

[0474] "Means for transmitting formatted script data to a user's terminal" refers to a communication device or software for transmitting script data to a device used by a user (e.g., a smartphone or a PC).

[0475] "Means for collecting user typing speed and click intensity" refers to sensors or software for collecting operation data such as a user's typing speed and click frequency and intensity in real time.

[0476] "Means for recognizing user emotions by analyzing collected data" refers to algorithms or software for analyzing collected operation data and determining the user's emotional state (e.g., excitement, tension, relief).

[0477] The "means for customizing generative models according to emotions" is a software module for adjusting the scenario generation algorithm and model output content based on the recognized user emotions.

[0478] This invention is a system that uses a generative model to personalize the theme, character settings, plot points, etc. of a script based on the user's emotions, and provides them through a user interface. Specific embodiments for implementing this invention are described below.

[0479] Server Operation

[0480] The server contains various software modules that perform functions such as:

[0481] 1. Receiving and Validating a Request

[0482] The server receives information about the script submitted by the user, such as themes, characterization, plot points, etc. It also checks that the received data is valid and contains all the required information, and returns an error message to the user if any data is missing or invalid.

[0483] 2. Emotion engine activation and analysis

[0484] The server starts an emotion engine (e.g., SentimentAnalyzer) and analyzes the user's input data and user interface operation history to recognize the user's emotion, such as the speed at which the text is entered, the content of the input, and the frequency and strength of clicks.

[0485] 3. Invoking the Generative Model

[0486] Based on the recognized emotion, a generative AI model (e.g., AIGenerator) is invoked, which generates customized dialogue, plot points, character development, etc. based on the user's emotion and the provided information.

[0487] 4. Content Formatting

[0488] The generated script elements are formatted into a script according to the format of scene descriptions, dialogues, character introductions, etc.

[0489] 5. Sending the Response

[0490] The formatted script data is sent to the user's device. The generated script is customized based on the user's emotions, resulting in a more personalized content.

[0491] Device behavior

[0492] The terminal provides a user interface and performs the following tasks:

[0493] 1. Getting User Input

[0494] The device gets input from the user about the screenplay's themes, characterization, plot points, etc. For example, it uses forms and select boxes to collect information.

[0495] 2. Collecting Emotional Data

[0496] The device collects data such as the user's typing speed, text content, and click frequency, and passes this information to an emotion engine, which analyzes the user's emotions in real time.

[0497] 3. Submitting a Request

[0498] The acquired input data and emotion data are sent to the server as an HTTP request.

[0499] 4. Receiving and Displaying Responses

[0500] Receives customized script data sent from the server and displays it to the user, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[0501] User Actions

[0502] The user does the following:

[0503] 1. Provision of information

[0504] The user inputs information about the script, such as the theme, character settings, and plot points, into the system. For example, the user inputs a sci-fi theme setting and character details.

[0505] 2. Submitting a Request

[0506] By pressing the "Generate" button, the user sends a generation request to the server based on the input information and the emotion data collected by the device.

[0507] 3. Check and edit the results

[0508] Review the customized script data and make edits and revisions as needed, fine-tuning dialogue, plot points, etc., to complete the final script.

[0509] Specific examples

[0510] As a concrete use case, consider a user writing a sci-fi themed screenplay. The user enters the following information:

[0511] Enter the theme of the scenario: SF

[0512] Enter your character's profile: Taro Tanaka, an engineer, brave and intelligent

[0513] Enter the plot point: A space station is destroyed by a meteorite impact and requires emergency repairs.

[0514] When a user enters the above information, the emotion engine detects impatience, and the generative AI model changes the dialogue accordingly to make it more urgent, for example, "Taro Tanaka: 'Our mission is to repair the space station. We don't have time, so hurry!'"

[0515] The system configuration described above makes it possible to generate a personalized script that reflects the user's emotions.

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

[0517] Step 1:

[0518] The user enters information about the script, such as themes, character settings, and plot points.

[0519] Input: User inputs theme "science fiction", character description "Taro Tanaka, engineer, brave and intelligent", and plot point "A space station is destroyed by a meteorite impact, requiring emergency repairs."

[0520] Output: Sends these inputs to the terminal.

[0521] Step 2:

[0522] The device collects additional data, such as the user's typing speed and click strength.

[0523] Input: User input behavior (typing speed, click strength)

[0524] Output: Collected typing speed and click strength data is saved on the device.

[0525] Step 3:

[0526] The device sends the collected information (script information, input speed, and click strength) to the server as an HTTP request.

[0527] Input: Theme, character preference, and plot point information entered by the user, as well as collected typing speed and click intensity data

[0528] Output: HTTP request sent to the server

[0529] Step 4:

[0530] Validates requests received by the server, checking for missing information or invalid formats.

[0531] Input: Screenplay information and related data received by the server

[0532] Output: Error message if there is an error, otherwise proceed to the next step

[0533] Step 5:

[0534] The server activates an emotion engine and analyzes the user's input data and operation data to recognize emotions.

[0535] Input: User interaction data, such as typing speed and click strength

[0536] Output: Analyzed user emotion data (e.g., impatience, excitement)

[0537] Step 6:

[0538] The server invokes a generative AI model to generate new script elements based on the user's emotions and input information.

[0539] Input: User theme, characterization, plot point information, and parsed emotional data

[0540] Output: New script elements based on emotions

[0541] Step 7:

[0542] The server formats the generated script elements into a standard script format.

[0543] Input: Generated script elements

[0544] Output: Formatted scenario data (e.g., dialogue and scene descriptions)

[0545] Step 8:

[0546] The server sends the formatted scenario data to the user's device.

[0547] Input: Formatted scenario data

[0548] Output: Scenario data sent to the user's device

[0549] Step 9:

[0550] The user checks the customized script data received on the device and edits or corrects it as necessary.

[0551] Input: Formatted scenario data

[0552] Output: A script finalized by the user

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

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

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

[0556] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0569] This invention is a system that receives information such as themes, character settings, and plot points of a script provided by the user, and generates new script elements using a generative model based on that information, thereby supporting efficient and creative scriptwriting.

[0570] Server Operation

[0571] The server plays a central role and performs the following main tasks:

[0572] 1. Receiving and Validating a Request

[0573] The server receives a request sent by a user. This request contains information such as the theme, character settings, and plot points of the script. The server first checks whether this data is valid. For example, if the theme or character information is missing, it returns an error message.

[0574] 2. Invoking the Generative Model

[0575] After receiving valid data, the server invokes a generative model (e.g., a machine learning model or AI algorithm) to generate new script elements. The model automatically creates dialogue, plot points, character development, etc. based on the information provided.

[0576] 3. Formatting Content

[0577] The generated script elements are in raw text format, so the server formats them into a script, specifically by organizing the content according to the format of scene descriptions, dialogues, character introductions, etc.

[0578] 4. Sending the Response

[0579] The formatted script data is returned to the user. Specifically, the generated results are sent to the user's device via an HTTP response or WebSocket.

[0580] Device behavior

[0581] The terminal provides the user interface and is responsible for the following:

[0582] 1. Getting User Input

[0583] The terminal collects input from the user about the script's theme, character settings, plot points, etc. This input is done through a GUI.

[0584] 2. Submitting a Request

[0585] The acquired input data is sent to the server. The terminal generates an HTTP request and sends it to the server, including the necessary parameters.

[0586] 3. Receiving and Displaying Responses

[0587] It receives the generated results from the server and displays them to the user, providing an interface for the user to edit and modify the displayed data.

[0588] User behavior

[0589] The user performs the following actions:

[0590] 1. Provision of information

[0591] Users input information about the script's theme, character settings, plot points, etc. For example, when creating a sci-fi script, they input information about the character, such as "Taro Tanaka, engineer, brave and intelligent."

[0592] 2. Sending a generation request

[0593] The user submits a generation request based on the information they entered. By pressing the "Generate" button, this information is sent to the server.

[0594] 3. Check and edit the results

[0595] Review the generated script data and edit it as needed, fine-tuning dialogue and plot points to complete the final script.

[0596] Specific examples

[0597] Below are some specific usage examples.

[0598] 1. The user selects "SF" as the theme of the script and enters "Taro Tanaka, engineer, brave and intelligent" as the character setting.

[0599] 2. The device sends this information to the server.

[0600] 3. The server verifies the information and calls the generative model to generate script elements such as:

[0601] Taro Tanaka: "Our mission is to repair the space station. We don't have much time, so hurry!"

[0602] Plot Point: A space station is severely damaged by a meteorite impact, requiring emergency repairs.

[0603] 4. The server formats the generated content, converts it into a script format, and sends it to the terminal.

[0604] 5. The terminal displays the generated results to the user, who can then check and edit them.

[0605] In this way, screenwriters can easily and efficiently generate high-quality scripts, allowing them to focus on their creative work.

[0606] The processing flow will be explained below.

[0607] Server Processing

[0608] Step 1:

[0609] The server receives requests from users via HTTP requests or WebSockets, which contain information such as the script's theme, character settings, and plot points.

[0610] Step 2:

[0611] The server validates the data it receives, checking that it is valid and contains all the required information, and returns an error message to the user if any data is missing or invalid.

[0612] Step 3:

[0613] With the data successfully validated, the server invokes a generative model, which then inputs this data into the model to generate new script dialogue, plot points, character development, etc.

[0614] Step 4:

[0615] The server formats the raw text returned by the generative model into a screenplay, specifically by organizing the content according to formats such as scene descriptions, dialogues, and character introductions.

[0616] Step 5:

[0617] The formatted script data is sent to the user's device as an HTTP response or WebSocket message.

[0618] Terminal handling

[0619] Step 1:

[0620] The terminal takes input from the user through a GUI, such as the screenplay's theme, character settings, and plot points. This information is entered using forms and select boxes.

[0621] Step 2:

[0622] The device sends the acquired data to the server in the form of an HTTP request. The device sets the necessary headers and parameters and sends the data using the POST method.

[0623] Step 3:

[0624] The terminal receives a response sent from the server, which includes the generated script data.

[0625] Step 4:

[0626] Presents the received script data to the user through a user interface, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[0627] User Action

[0628] Step 1:

[0629] The user inputs information about the script, such as the theme, character settings, and plot points, into the terminal. For example, a sci-fi theme setting and character details can be entered.

[0630] Step 2:

[0631] By pressing the "Generate" button, the user sends a generation request to the server based on the information entered.

[0632] Step 3:

[0633] The user confirms the generated results returned from the server, checks the script data displayed on the terminal, and makes edits or corrections as necessary.

[0634] Step 4:

[0635] Users can save or export their edited script, select the file format and destination, and complete the final script.

[0636] This series of steps allows the user, terminal, and server processes to work together and the script creation process to proceed smoothly.

[0637] Example 1

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

[0639] In conventional scenario creation, manually setting themes, characters, and constructing stories requires time and effort, limiting the scope for creativity. Furthermore, efficient scenario creation is difficult because there is no established method for formatting the generated scenario elements and effectively providing them to users.

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

[0641] In this invention, the server includes means for receiving data such as the scenario theme, character settings, and story main points from the user, means for calling a generation algorithm based on the data to generate new scenario elements, means for formatting the generated content into a scenario format, and means for transmitting the formatted scenario data to the user's device. This enables the efficient generation of high-quality, creative scenarios.

[0642] 1. "User" refers to a person or organization that uses the system to provide data such as the scenario's theme, character settings, and story key points.

[0643] 2. A "scenario" is the overall structure of a story that combines the story's theme, character settings, plot points, etc.

[0644] 3. "Theme" is a concept that indicates the central subject, genre, or setting of a story.

[0645] 4. A "character" is a character who has a specific role within the scenario.

[0646] 5. A "story point" is a point that indicates an important event or development in a story.

[0647] 6. "Data" refers to information received by the system, such as themes, character settings, and story points.

[0648] 7. "Generative Algorithm" refers to artificial intelligence techniques or machine learning models that generate new scenario elements based on provided data.

[0649] 8. "Scenario Elements" are the individual parts that make up a scenario, such as generated dialogue, plot points, character development, etc.

[0650] 9. "Formatting" refers to the process of organizing and converting the generated scenario elements into an appropriate scenario format.

[0651] 10. "Device" means an electronic device, such as a computer, smartphone, or tablet, that a User uses to access the System.

[0652] This invention is a system that receives data such as the scenario theme, character settings, and story key points provided by the user, and uses a generation algorithm to generate new scenario elements based on that data, thereby supporting efficient and creative scenario creation.

[0653] Server Operation

[0654] The server plays a central role and performs the following main tasks:

[0655] 1. Receiving and validating data from the user

[0656] The server receives a request sent by the user. This request contains data such as the scenario's theme, character settings, and story summary. The server first checks whether this data is valid. For example, if the theme or character information is missing, it returns an error message.

[0657] 2. Invoking the generation algorithm

[0658] After receiving valid data, the server invokes a generative algorithm (e.g., an AI technology such as GPT-4) to generate new scenario elements. The algorithm automatically creates dialogue, story points, character development, etc. based on the provided data.

[0659] 3. Formatting the generated data

[0660] The generated scenario elements are in raw text format, so the server formats them into an appropriate scenario format, specifically by arranging and converting the content according to the format of scene descriptions, dialogues, character introductions, etc.

[0661] 4. Sending formatted data

[0662] The formatted scenario data is returned to the user's device. Specifically, the generated results are sent to the user's device using protocols such as HTTP responses or WebSockets.

[0663] Device behavior

[0664] The terminal provides a user interface and is responsible for the following processes:

[0665] 1. Getting User Input

[0666] The terminal collects input from the user about the scenario's theme, character settings, storyline, etc. This input is done through a GUI.

[0667] 2. Submitting a Request

[0668] The acquired data is sent to the server. The device generates an HTTP request and sends it to the server, including the necessary parameters.

[0669] 3. Receiving and Displaying Responses

[0670] It receives the generated results from the server and displays them to the user, providing an interface for the user to edit and modify the displayed data.

[0671] User behavior

[0672] The user performs the following actions:

[0673] 1. Provision of information

[0674] Users input data into the system, such as the scenario's theme, character settings, main points of the story, etc. For example, when creating a science fiction scenario, users might input information such as "engineer, brave, and intelligent" for the characters.

[0675] 2. Sending a generation request

[0676] The user submits a generation request based on the information they entered. By pressing the "Generate" button, this data is sent to the server.

[0677] 3. Check and edit the results

[0678] Check the generated scenario data and edit it as necessary, fine-tuning the dialogue and key points of the story to complete the final scenario.

[0679] Specific examples

[0680] Example

[0681] 1. The user selects "science fiction" as the scenario theme and enters "engineer, brave and intelligent" as the character description.

[0682] 2. The user enters the main point of the story: "A space station is severely damaged by a meteorite impact, requiring emergency repairs."

[0683] 3. The device sends this data to the server.

[0684] 4. The server validates the data and invokes a generation algorithm to generate the following scenario elements:

[0685] Character: "Our mission is to repair the space station. We don't have much time, we have to hurry!"

[0686] Scene description: A space station is severely damaged by a meteorite impact, requiring emergency repairs.

[0687] 5. The server formats the generated content, converts it into a scenario format, and sends it to the terminal.

[0688] 6. The terminal displays the generated results to the user, who can then check and edit them.

[0689] Prompt Sentence Examples

[0690] Theme: Sci-Fi

[0691] Character Profile: Engineer, brave and intelligent

[0692] Summary: A space station is destroyed by a meteorite and requires emergency repairs.

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

[0694] Program processing steps

[0695] Step 1: Collecting User Input

[0696] User behavior

[0697] Through the system's interface, users input data such as the scenario's theme, character settings, and story key points. For example, they can select "science fiction" as the theme, provide "engineer, brave and intelligent" as the character settings, and provide "a space station is destroyed by a meteorite impact and requires emergency repairs" as the story key point.

[0698] input

[0699] The scenario's theme, character settings, and main points of the story.

[0700] output

[0701] Collected user input data.

[0702] Specific actions

[0703] The user enters data into the input fields and clicks the Submit button.

[0704] Step 2: Submitting the request

[0705] Device behavior

[0706] The device sends the data collected from the user to the server as an HTTP request. Specifically, it converts the input data into JSON format and sends it to the server.

[0707] input

[0708] Collected user input data.

[0709] output

[0710] An HTTP request to the server.

[0711] Specific actions

[0712] The terminal generates data in JSON format and sends the data to the server using the HTTP protocol.

[0713] Step 3: Receiving and validating the request

[0714] Server Operation

[0715] The server receives an HTTP request sent by a user. It validates the data contained in the request (theme, character setting, storyline) to ensure it is valid. If any information is missing or invalid, the server generates an error message and sends it to the terminal.

[0716] input

[0717] HTTP request from the user.

[0718] output

[0719] Data that passes validation, or an error message.

[0720] Specific actions

[0721] The server parses the data and performs validation processing.

[0722] Step 4: Invoke the generation algorithm

[0723] Server Operation

[0724] The server then invokes a generation algorithm (e.g., AI technology such as GPT-4) based on the validated data, which generates new scenario elements (dialogue, story points, character development) based on the provided data.

[0725] input

[0726] Data that passed validation.

[0727] output

[0728] Generated scenario elements (dialogue, story points, character development).

[0729] Specific actions

[0730] The server invokes the generation algorithm to generate scenario elements.

[0731] Step 5: Formatting the generated data

[0732] Server Operation

[0733] The server then formats the generated scenario elements into an appropriate scenario format, specifically by arranging and converting the content according to the format of scene descriptions, dialogues, character introductions, etc.

[0734] input

[0735] Generated scenario elements.

[0736] output

[0737] Scenario data formatted in scenario format.

[0738] Specific actions

[0739] The server converts the content into a scenario format and generates formatted data.

[0740] Step 6: Sending formatted data

[0741] Server Operation

[0742] The server sends the formatted scenario data to the user's device. Specifically, it sends the formatted data to the terminal as an HTTP response.

[0743] input

[0744] Scenario data formatted in scenario format.

[0745] output

[0746] The HTTP response to the user's device.

[0747] Specific actions

[0748] The server generates an HTTP response and sends the formatted data.

[0749] Step 7: Review and edit the results

[0750] Device behavior

[0751] The terminal receives the generated results from the server and displays them to the user. The user can check the generated scenario data and edit it as necessary. The user can adjust the dialogue and story points through the interface.

[0752] input

[0753] Generated scenario data received from the server.

[0754] output

[0755] Scenario data displayed to the user, and the results of editing by the user.

[0756] Specific actions

[0757] The terminal analyzes and displays the received data, and the user performs editing operations.

[0758] (Application example 1)

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

[0760] In recent years, the demand for scriptwriting has increased, creating a need for high-quality scripts to be written quickly and efficiently. However, traditional methods require scriptwriters to expend a great deal of time and effort, which can be particularly burdensome when themes, character settings, and plot points are complex. Furthermore, the editing process after script generation is cumbersome, making it difficult to achieve an efficient workflow. To solve these issues, a system that can provide consistent support from script generation to editing is needed.

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

[0762] In this invention, the server includes means for receiving information such as the script theme, character settings, and plot points from the user, means for calling a generative model based on the information and generating new script elements, means for formatting the generated content into a script format, means for transmitting the formatted script data to the user's terminal, and display means for the user to check and edit the generated script data. This allows users to easily generate high-quality scripts and further edit the generated script in real time through an interface. Furthermore, the use of a cloud server allows for rapid large-scale data processing, providing users with a seamless experience.

[0763] A "theme" refers to the main subject or specific content of a script, the central idea that influences the progression of the story.

[0764] "Character settings" include detailed information about the personalities, backgrounds, roles, etc. of the characters who appear in the script.

[0765] A "plot point" is an element that is an important event or turning point in the progression of a story, and forms the basis for the story's development.

[0766] A "generative model" refers to an algorithm or system that uses machine learning or artificial intelligence to automatically generate new script elements based on user-provided information.

[0767] "Script format" refers to the format in which the generated content is organized according to the format of scene descriptions, dialogue, character introductions, etc.

[0768] A "cloud server" refers to a remote server that can be accessed via the Internet and provides large-scale data processing and storage functions.

[0769] "User's terminal" refers to a computer, smartphone, tablet, etc. used by a user, which is a device for receiving and displaying generated script data.

[0770] "Display means" refers to an interface that allows a user to visually check and edit the generated script data.

[0771] "Data validation" is the step where we check whether the information provided by the user is missing or in an invalid format and take appropriate action.

[0772] "Means for making it editable" refers to the ability for users to modify and fine-tune the generated script as needed.

[0773] This invention is a system that receives information such as the theme, character settings, and plot points of a script provided by a user, and generates new script elements using a generative model based on that information. Specific embodiments are described below.

[0774] Server Operation

[0775] The server plays a central role in this system and performs the following main processes:

[0776] 1. Receiving and validating a request:

[0777] The server receives a request sent by a user using the HTTPS protocol. This request contains information such as the script's theme, character settings, and plot points. The server first checks whether this data is valid. For example, if the theme or character information is missing, it returns an error message.

[0778] 2. Invoke the generative model:

[0779] Given valid data, the server invokes a generative model (e.g., a generative AI model like GPT-4) to generate new script elements, such as dialogue, plot points, and character development, automatically based on the information provided.

[0780] 3. Formatting content:

[0781] The generated script elements are in raw text format, so the server formats them into a script, specifically by organizing the content according to the format of scene descriptions, dialogues, character introductions, etc.

[0782] 4. Sending the response:

[0783] The formatted script data is sent to the user's device. Specifically, the generated results are sent to the user's device via HTTP response or WebSocket.

[0784] Device behavior

[0785] The terminal provides the user interface and is responsible for the following:

[0786] 1. Getting user input:

[0787] The terminal collects input from the user about the script's theme, character settings, plot points, etc. This input is done through a GUI.

[0788] 2. Submit your request:

[0789] The acquired input data is sent to the server. The terminal generates an HTTPS request and sends it to the server, including the necessary parameters.

[0790] 3. Receiving and Displaying Responses:

[0791] It receives the generated results from the server and displays them to the user, providing an interface for the user to edit and modify the displayed data.

[0792] User behavior

[0793] The user performs the following actions:

[0794] 1. Provision of information:

[0795] Users input information about the script's theme, character settings, plot points, etc. For example, if creating a sci-fi script, they input information about the character, such as "engineer, brave, and intelligent."

[0796] 2. Send the generation request:

[0797] The user submits a generation request based on the information they entered. By pressing the "Generate" button, this information is sent to the server.

[0798] 3. Review and edit the results:

[0799] Review the generated script data and edit it as needed, fine-tuning dialogue and plot points to complete the final script.

[0800] Specific examples

[0801] Let's consider a specific example of a movie production company using this system. The theme is "Tokyo of the future," the character is a "police officer of the future with a very keen intuition," and the plot point is a "mysterious disappearance." The following prompt is sent to the generative AI model:

[0802] Example prompt sentence:

[0803] Theme: Future Tokyo

[0804] Character: A police officer from the future with a keen intuition

[0805] Plot Point: Mysterious Disappearance

[0806] Generated script elements please.

[0807] As described above, this invention allows users to easily generate high-quality scripts and then edit the generated scripts in real time through an interface. Furthermore, by using a cloud server, large-scale data processing can be performed quickly, providing users with a seamless experience.

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

[0809] Step 1:

[0810] The user inputs information such as the script's theme, character settings, and plot points through the device's user interface. This information is collected as input data. The input includes specific details such as the theme being "Tokyo of the future," the character setting being "a police officer of the future with a very keen intuition," and the plot point being "a mysterious disappearance."

[0811] Step 2:

[0812] The device sends the collected input data to the server as an HTTPS request, which includes the user's input such as theme, character settings, and plot points.

[0813] Step 3:

[0814] The server validates the data of the received request. This validation process checks whether the data is complete and not invalid. For example, if character information is missing, an error message is generated and returned to the user. The input of this step is the input data from the user, and the output is the validation result.

[0815] Step 4:

[0816] Once valid data is verified, the server invokes a generative AI model (e.g., GPT-4). The generative AI model generates new script elements based on the provided theme, character settings, and plot points. The input is the validated data, and the output is the generated script elements. For example, a script element might be generated such as "A police officer from the future investigates a mysterious disappearance in Tokyo."

[0817] Step 5:

[0818] The generated script elements are returned to the server in raw text format, which the server then formats into a user-friendly script. Specifically, the script is organized according to the format of scene descriptions, dialogues, character introductions, etc. The input of this step is the generated raw text, and the output is formatted script data.

[0819] Step 6:

[0820] The server generates an HTTP response to send the formatted script data to the user's terminal. This response is used as a display means for the user to check and edit. The input is the formatted script data, and the output is the data to be sent to the user's terminal.

[0821] Step 7:

[0822] The terminal displays the script data received from the server. The user reviews this data and makes edits as needed, for example, fine-tuning the dialogue in the generated script or adding plot points. The input is the data received from the server, and the output is the data displayed and edited in the user interface.

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

[0824] This invention is a system that uses a generative model to generate new script elements based on information provided by the user, such as the script's theme, character settings, and plot points, and also combines it with an emotion engine that recognizes the user's emotions and customizes the script content, making it possible to generate more personalized scripts.

[0825] Server Operation

[0826] The server receives a request from the user and performs the following process:

[0827] 1. Receiving and Validating a Request

[0828] The server receives information about the script submitted by the user, such as themes, characterization, plot points, etc. It also checks that the received data is valid and contains all the required information, and returns an error message to the user if any data is missing or invalid.

[0829] 2. Emotion engine activation and analysis

[0830] The server activates an emotion engine and analyzes the user's input data and user interface operation history to recognize the user's emotions, such as the speed at which the text is entered, the content of the input, and the frequency and strength of clicks.

[0831] 3. Invoking the Generative Model

[0832] Based on the recognized emotions, a generative model is invoked, which generates customized dialogue, plot points, character development, etc. based on the user's emotions and the information provided.

[0833] 4. Content Formatting

[0834] The generated script elements are formatted into a script according to the format of scene descriptions, dialogues, character introductions, etc.

[0835] 5. Sending the Response

[0836] The formatted script data is sent to the user's device. The generated script is customized based on the user's emotions, resulting in a more personalized content.

[0837] Device behavior

[0838] The terminal provides a user interface and performs the following processes:

[0839] 1. Getting User Input

[0840] The device gets input from the user about the screenplay's themes, characterization, plot points, etc. For example, it uses forms and select boxes to collect information.

[0841] 2. Collecting Emotional Data

[0842] The device collects data such as the user's typing speed, text content, and click frequency, and passes this information to an emotion engine, which analyzes the user's emotions in real time.

[0843] 3. Submitting a Request

[0844] The acquired input data and emotion data are sent to the server as an HTTP request.

[0845] 4. Receiving and Displaying Responses

[0846] Receives customized script data sent from the server and displays it to the user, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[0847] User Actions

[0848] The user performs the following operations:

[0849] 1. Provision of information

[0850] The user inputs information about the script, such as the theme, character settings, and plot points, into the system. For example, the user inputs a sci-fi theme setting and character details.

[0851] 2. Submitting a Request

[0852] By pressing the "Generate" button, the user sends a generation request to the server based on the input information and the emotion data collected by the device.

[0853] 3. Check and edit the results

[0854] Review the customized script data and make edits and revisions as needed, fine-tuning dialogue, plot points, etc., to complete the final script.

[0855] Specific examples

[0856] As a concrete use case, consider a user writing a science fiction-themed screenplay. The user enters the following information:

[0857] Theme: Sci-Fi

[0858] Character Description: "Taro Tanaka, engineer, brave and intelligent"

[0859] Plot Point: "A space station is severely damaged by a meteorite impact and requires emergency repairs."

[0860] While the user is typing, the emotion engine analyzes their typing speed and click strength to determine if they are impatient. The server then uses a generative model to generate a script that reflects the user's emotions. For example, the tone of the dialogue may be adjusted to create a more tense atmosphere.

[0861] The generated script looks like this:

[0862] Taro Tanaka: "Our mission is to repair the space station. We don't have much time, so hurry!"

[0863] Finally, the server formats the customized script and sends it to the user's device, where the user can review and edit it to complete the final script.

[0864] In this way, by combining emotion engines, more personalized script generation based on the user's emotions can be achieved.

[0865] The processing flow will be explained below.

[0866] Server Processing

[0867] Step 1:

[0868] The server receives requests from users via HTTP requests, WebSockets, etc. The requests contain information such as the script's theme, character settings, and plot points.

[0869] Step 2:

[0870] The server validates the received data, checking whether enough theme and character information has been provided or if any information is missing, and returns an error message to the user if any data is missing or invalid.

[0871] Step 3:

[0872] The server activates an emotion engine and analyzes the user's input data and the user interface operation history to recognize the user's emotion, such as input speed, input content, click frequency and intensity, etc.

[0873] Step 4:

[0874] Based on the emotion data recognized by the emotion engine, a generative model is invoked, which generates new script elements (dialogue, plot points, character development, etc.) based on the user's emotions and the information provided.

[0875] Step 5:

[0876] The generated content is formatted into a script, specifically by organizing the content according to a format such as scene descriptions, dialogue, and character introductions.

[0877] Step 6:

[0878] The formatted script data is sent to the user's device as an HTTP response or WebSocket message.

[0879] Terminal handling

[0880] Step 1:

[0881] The terminal receives input from the user through a GUI, such as the script's theme, character settings, and plot points. The input is collected using forms and select boxes.

[0882] Step 2:

[0883] The device collects data such as the user's typing speed, text content, and click frequency and intensity, and passes this data to the emotion engine. This data is collected in real time as you type.

[0884] Step 3:

[0885] The acquired input data and emotion data are sent to the server in the form of an HTTP request, with appropriate headers and parameters set.

[0886] Step 4:

[0887] The terminal receives the response sent from the server, which includes the generated customized script data.

[0888] Step 5:

[0889] Presents the received script data to the user through a user interface, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[0890] User behavior

[0891] Step 1:

[0892] The user inputs information about the script, such as the theme, character settings, and plot points, into the terminal. For example, the user inputs a sci-fi theme or character details.

[0893] Step 2:

[0894] The user presses the "Generate" button to send a generation request to the server based on the input information and the emotion data collected by the device.

[0895] Step 3:

[0896] The user confirms the customized script data returned from the server, checks the script data displayed on the terminal, and makes edits or corrections as necessary.

[0897] Step 4:

[0898] Users can save or export their edited script, select the file format and destination, and complete the final script.

[0899] This series of steps allows the user, device, and server processes to work together to smoothly advance the script generation process. Customization based on the user's emotions results in a more personalized script.

[0900] Example 2

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

[0902] Conventional script generation systems were able to generate and format script elements based on information received from users, but they were unable to generate personalized scripts that took the user's emotions into account. Because they were unable to create dialogue or set scenes that reflected the user's emotions, it was difficult to create a script that reflected each individual's emotions and intentions during the creative process.

[0903] The specific processing by the specific processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes means for receiving information such as the theme, character settings, and plot points of the script from the user, means for calling a generative model based on the information and generating new script elements, means for formatting the generated content into a script format, means for sending the formatted script data to the user's terminal, means for activating an emotion engine that recognizes the user's emotions and analyzing the user's input data and operation history, and means for customizing the generative model based on the recognized emotions. This makes it possible to generate a script personalized according to the user's emotions.

[0904] A "user" is an entity that uses the system to provide information such as the theme, character settings, and plot points of a script and receives the generated script.

[0905] A "server" is a computer device that receives requests from users and performs a series of processes such as generating, formatting, and transmitting a script.

[0906] "Theme" is information that defines the basic subject matter and genre of the entire script.

[0907] "Character settings" are information that defines the detailed characteristics and roles of the characters that appear in the script.

[0908] A "plot point" is information that indicates an important event or turning point in the progression of a script.

[0909] A "generative model" is an algorithm or program for generating new script elements based on user-provided information.

[0910] "Script elements" are various pieces of content such as dialogue, scene descriptions, and character details that are generated by a generative model.

[0911] An "emotion engine" is a software component that analyzes a user's input data and operation history to recognize emotions.

[0912] "Emotional data" is information such as typing speed, click frequency, and content that is collected to reflect a user's emotions.

[0913] "Formatting" is the process of organizing the generated script elements into a format such as scene descriptions, dialogue, and character introductions.

[0914] An "HTTP request" is a communication format that follows a protocol for sending information from a user's terminal to a server.

[0915] A "prompt sentence" is data in the form of a specific document that is input to a generative model.

[0916] This invention relates to a system that generates new script elements based on information such as themes, character settings, and plot points of a script provided by a user, and also recognizes the user's emotions to personalize the script content. Specific methods for implementing this system are described below.

[0917] Server Operation

[0918] The server uses several software components to process the script generation. First, the server receives the HTTP request sent by the user. This request contains information about the script's theme, character settings, plot points, etc. The server validates the received information to ensure that all required data is present.

[0919] Next, the server launches the emotion engine, which uses a software library called "EmotionalAnalyzer.dll" to analyze the user's input data and operation history (input speed, click frequency, etc.) to recognize the user's emotions. This allows the server to understand the user's emotional state, such as whether they are anxious or relaxed.

[0920] The server then invokes the generative AI model, implemented in the file "ScriptGenerator.ai," which takes emotion data and user-provided data in the form of a prompt. For example, it generates the following prompt:

[0921] "Theme: Sci-Fi, Character: Tanaka Taro, engineer, brave and intelligent, Plot point: A space station is destroyed by a meteorite and requires emergency repairs. Generate tense dialogue that takes into account the user's impatience."

[0922] The generative AI model generates new script elements based on this prompt.

[0923] The generated script elements are formatted into a script using "ScriptFormatter.dll", for example, into scene descriptions, dialogues, character introductions, etc.

[0924] Finally, the formatted script data is sent to the user's device as an HTTP response.

[0925] Device behavior

[0926] The terminal provides a user interface and takes input from the user about the screenplay's theme, character settings, plot points, etc. This input is done through forms and select boxes and stored in a variable, for example "themeInput.value".

[0927] In addition, the device collects data such as the user's typing speed and click frequency in real time and converts it into a format that can be passed to the emotion engine, allowing the server to recognize the user's emotions.

[0928] When the user completes all input and clicks the "Generate" button, the device sends the input data and emotion data to the server as a single HTTP request.

[0929] After receiving the HTTP response from the server, the device displays the received script data to the user in an appropriate format. For example, the dialogue portion is displayed as "quoteElement.innerHTML".

[0930] User Actions

[0931] The user inputs information about the script, such as the theme, character settings, and plot points of the script into the system. For example, they input a sci-fi theme and character details. After completing all the input, the user clicks the "Generate" button to send the request to the server.

[0932] The generated script data is reviewed and, if necessary, the dialogue, scenes, etc. are edited. Finally, the user creates a completed script using a tool such as a text editor.

[0933] In this way, by combining emotion engines, more personalized script generation based on the user's emotions can be achieved.

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

[0935] Step 1:

[0936] Receiving and Validating a Request

[0937] 1. The server receives an HTTP request sent by the user.

[0938] Input: An HTTP request containing information about the screenplay's theme, characterization, plot points, etc.

[0939] Output: Various extracted information.

[0940] 2. The server extracts the received data and checks for missing information or invalid formats.

[0941] Data processing: Checking themes and character settings, and validating that all necessary information is available.

[0942] Behavior: If validation fails, an error message is generated and returned to the user.

[0943] Step 2:

[0944] Emotion engine activation and analysis

[0945] 1. The server starts the emotion engine.

[0946] Input: Extracted user input data and operation history (typing speed, click frequency, etc.).

[0947] Output: The user's emotional state.

[0948] 2. The emotion engine analyzes the input data and recognizes the user's emotions.

[0949] Data calculations: Sentiment analysis using text entry speed, click frequency, and input content.

[0950] How it works: The emotion engine uses the data to determine the user's emotional state, such as whether they are anxious.

[0951] Step 3:

[0952] Invoking the generative model

[0953] 1. The server invokes the generative AI model based on the emotions recognized by the emotion engine.

[0954] Input: User emotional data, script themes, characterization, and plot points.

[0955] Output: The newly generated script element.

[0956] 2. The server converts this data into prompt sentence format and inputs it into the generative model.

[0957] Data processing: Prompt sentence generation.

[0958] How it works: The generative AI model generates new script elements based on the prompt. For example, it generates the following prompt:

[0959] "Theme: Sci-Fi, Character: Tanaka Taro, engineer, brave and intelligent, Plot point: A space station is destroyed by a meteorite and requires emergency repairs. Generate tense dialogue that takes into account the user's impatience."

[0960] Step 4:

[0961] Content Formatting

[0962] 1. The server formats the script elements received from the generative model into a script format.

[0963] Input: Generated script elements.

[0964] Output: Formatted script data.

[0965] 2. The server uses "ScriptFormatter.dll" to organize the generated elements into formats such as scene descriptions, dialogues, character introductions, etc.

[0966] Data processing: Formatting various script elements into a specified format.

[0967] Step 5:

[0968] Sending a response

[0969] 1. The server sends the formatted script data to the user's device as an HTTP response.

[0970] Input: Formatted script data.

[0971] Output: The HTTP response sent to the user's device.

[0972] Step 6:

[0973] Getting User Input

[0974] 1. The device obtains information such as theme, character settings, and plot points through the user interface.

[0975] Input: User-supplied themes, characterizations, and plot points.

[0976] Output: User input data stored on the device.

[0977] 2. The device stores the collected data in a variable, for example, "themeInput.value".

[0978] Behavior: Provides input forms and select boxes.

[0979] Step 7:

[0980] Collecting Emotional Data

[0981] 1. The device collects emotional data such as the user's text input speed, click frequency, and input content.

[0982] Input: User operation data.

[0983] Output: Collected emotion data.

[0984] 2. The device converts this data into a format that can be passed to the emotion engine and stores it in variables.

[0985] Step 8:

[0986] Submitting a Request

[0987] 1. The device sends the collected user input data and emotion data together as an HTTP request to the server.

[0988] Input: Collected user input data and sentiment data.

[0989] Output: The HTTP request sent to the server.

[0990] Step 9:

[0991] Receiving and displaying the response

[0992] 1. The terminal receives the HTTP response returned from the server.

[0993] Input: The HTTP response from the server.

[0994] Output: Received script data.

[0995] 2. The terminal displays the received script data in an appropriate format for the user.

[0996] Behavior: The dialogue is displayed as "quoteElement.innerHTML".

[0997] (Application example 2)

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

[0999] Conventional script generation systems have difficulty identifying user emotions and reflecting them in the script content, which has led to the issue of insufficient script generation personalized for each user. Therefore, there is a need for a method to generate scripts that are more individualized and in line with emotions by generating scripts based on the user's emotions.

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

[1001] In this invention, the server includes means for receiving information such as the theme, character settings, and plot points of the script from the user, means for calling a generative model based on the information and generating new script elements, means for formatting the generated content into a script format, means for sending the formatted script data to the user's terminal, means for collecting the user's input speed and click strength, means for analyzing the collected data to recognize the user's emotions, and means for customizing the generative model according to the emotions. This enables more personalized script generation by analyzing the user's emotions in real time and customizing the script content based on that.

[1002] "Means for receiving information from a user about the screenplay's theme, character settings, plot points, etc." refers to a device or software that provides an interface for a user to input the screenplay's theme, character details, and major plot points.

[1003] The "means for invoking a generative model based on the information and generating new script elements" refers to an algorithm or software module for using artificial intelligence to generate new scenario elements based on the acquired user information.

[1004] "Means for formatting the generated content into a script" refers to a device or software that organizes the generated scenario elements, such as dialogue, scene descriptions, and character introductions, according to a standard scenario format and converts them into an appropriate format.

[1005] "Means for transmitting formatted script data to a user's terminal" refers to a communication device or software for transmitting script data to a device used by a user (e.g., a smartphone or a PC).

[1006] "Means for collecting user typing speed and click intensity" refers to sensors or software for collecting operation data such as a user's typing speed and click frequency and intensity in real time.

[1007] "Means for recognizing user emotions by analyzing collected data" refers to algorithms or software for analyzing collected operation data and determining the user's emotional state (e.g., excitement, tension, relief).

[1008] The "means for customizing generative models according to emotions" is a software module for adjusting the scenario generation algorithm and model output content based on the recognized user emotions.

[1009] This invention is a system that uses a generative model to personalize the theme, character settings, plot points, etc. of a script based on the user's emotions, and provides them through a user interface. Specific embodiments for implementing this invention are described below.

[1010] Server Operation

[1011] The server contains various software modules that perform functions such as:

[1012] 1. Receiving and Validating a Request

[1013] The server receives information about the script submitted by the user, such as themes, characterization, plot points, etc. It also checks that the received data is valid and contains all the required information, and returns an error message to the user if any data is missing or invalid.

[1014] 2. Emotion engine activation and analysis

[1015] The server starts an emotion engine (e.g., SentimentAnalyzer) and analyzes the user's input data and user interface operation history to recognize the user's emotion, such as the speed at which the text is entered, the content of the input, and the frequency and strength of clicks.

[1016] 3. Invoking the Generative Model

[1017] Based on the recognized emotion, a generative AI model (e.g., AIGenerator) is invoked, which generates customized dialogue, plot points, character development, etc. based on the user's emotion and the provided information.

[1018] 4. Content Formatting

[1019] The generated script elements are formatted into a script according to the format of scene descriptions, dialogues, character introductions, etc.

[1020] 5. Sending the Response

[1021] The formatted script data is sent to the user's device. The generated script is customized based on the user's emotions, resulting in a more personalized content.

[1022] Device behavior

[1023] The terminal provides a user interface and performs the following tasks:

[1024] 1. Getting User Input

[1025] The device gets input from the user about the screenplay's themes, characterization, plot points, etc. For example, it uses forms and select boxes to collect information.

[1026] 2. Collecting Emotional Data

[1027] The device collects data such as the user's typing speed, text content, and click frequency, and passes this information to an emotion engine, which analyzes the user's emotions in real time.

[1028] 3. Submitting a Request

[1029] The acquired input data and emotion data are sent to the server as an HTTP request.

[1030] 4. Receiving and Displaying Responses

[1031] Receives customized script data sent from the server and displays it to the user, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[1032] User Actions

[1033] The user does the following:

[1034] 1. Provision of information

[1035] The user inputs information about the script, such as the theme, character settings, and plot points, into the system. For example, the user inputs a sci-fi theme setting and character details.

[1036] 2. Submitting a Request

[1037] By pressing the "Generate" button, the user sends a generation request to the server based on the input information and the emotion data collected by the device.

[1038] 3. Check and edit the results

[1039] Review the customized script data and make edits and revisions as needed, fine-tuning dialogue, plot points, etc., to complete the final script.

[1040] Specific examples

[1041] As a concrete use case, consider a user writing a sci-fi themed screenplay. The user enters the following information:

[1042] Enter the theme of the scenario: SF

[1043] Enter your character's profile: Taro Tanaka, an engineer, brave and intelligent

[1044] Enter the plot point: A space station is destroyed by a meteorite impact and requires emergency repairs.

[1045] When a user enters the above information, the emotion engine detects impatience, and the generative AI model changes the dialogue accordingly to make it more urgent, for example, "Taro Tanaka: 'Our mission is to repair the space station. We don't have time, so hurry!'"

[1046] The system configuration described above makes it possible to generate a personalized script that reflects the user's emotions.

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

[1048] Step 1:

[1049] The user enters information about the script, such as themes, character settings, and plot points.

[1050] Input: User inputs theme "science fiction", character description "Taro Tanaka, engineer, brave and intelligent", and plot point "A space station is destroyed by a meteorite impact, requiring emergency repairs."

[1051] Output: Sends these inputs to the terminal.

[1052] Step 2:

[1053] The device collects additional data, such as the user's typing speed and click strength.

[1054] Input: User input behavior (typing speed, click strength)

[1055] Output: Collected typing speed and click strength data is saved on the device.

[1056] Step 3:

[1057] The device sends the collected information (script information, input speed, and click strength) to the server as an HTTP request.

[1058] Input: Theme, character preference, and plot point information entered by the user, as well as collected typing speed and click intensity data

[1059] Output: HTTP request sent to the server

[1060] Step 4:

[1061] Validates requests received by the server, checking for missing information or invalid formats.

[1062] Input: Screenplay information and related data received by the server

[1063] Output: Error message if there is an error, otherwise proceed to the next step

[1064] Step 5:

[1065] The server activates an emotion engine and analyzes the user's input data and operation data to recognize emotions.

[1066] Input: User interaction data, such as typing speed and click strength

[1067] Output: Analyzed user emotion data (e.g., impatience, excitement)

[1068] Step 6:

[1069] The server invokes a generative AI model to generate new script elements based on the user's emotions and input information.

[1070] Input: User theme, characterization, plot point information, and parsed emotional data

[1071] Output: New script elements based on emotions

[1072] Step 7:

[1073] The server formats the generated script elements into a standard script format.

[1074] Input: Generated script elements

[1075] Output: Formatted scenario data (e.g., dialogue and scene descriptions)

[1076] Step 8:

[1077] The server sends the formatted scenario data to the user's device.

[1078] Input: Formatted scenario data

[1079] Output: Scenario data sent to the user's device

[1080] Step 9:

[1081] The user checks the customized script data received on the device and edits or corrects it as necessary.

[1082] Input: Formatted scenario data

[1083] Output: A script finalized by the user

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

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

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

[1087] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1100] This invention is a system that receives information such as themes, character settings, and plot points of a script provided by the user, and generates new script elements using a generative model based on that information, thereby supporting efficient and creative scriptwriting.

[1101] Server Operation

[1102] The server plays a central role and performs the following main tasks:

[1103] 1. Receiving and Validating a Request

[1104] The server receives a request sent by a user. This request contains information such as the theme, character settings, and plot points of the script. The server first checks whether this data is valid. For example, if the theme or character information is missing, it returns an error message.

[1105] 2. Invoking the Generative Model

[1106] After receiving valid data, the server invokes a generative model (e.g., a machine learning model or AI algorithm) to generate new script elements. The model automatically creates dialogue, plot points, character development, etc. based on the information provided.

[1107] 3. Formatting Content

[1108] The generated script elements are in raw text format, so the server formats them into a script, specifically by organizing the content according to the format of scene descriptions, dialogues, character introductions, etc.

[1109] 4. Sending the Response

[1110] The formatted script data is returned to the user. Specifically, the generated results are sent to the user's device via an HTTP response or WebSocket.

[1111] Device behavior

[1112] The terminal provides the user interface and is responsible for the following:

[1113] 1. Getting User Input

[1114] The terminal collects input from the user about the script's theme, character settings, plot points, etc. This input is done through a GUI.

[1115] 2. Submitting a Request

[1116] The acquired input data is sent to the server. The terminal generates an HTTP request and sends it to the server, including the necessary parameters.

[1117] 3. Receiving and Displaying Responses

[1118] It receives the generated results from the server and displays them to the user, providing an interface for the user to edit and modify the displayed data.

[1119] User behavior

[1120] The user performs the following actions:

[1121] 1. Provision of information

[1122] Users input information about the script's theme, character settings, plot points, etc. For example, when creating a sci-fi script, they input information about the character, such as "Taro Tanaka, engineer, brave and intelligent."

[1123] 2. Sending a generation request

[1124] The user submits a generation request based on the information they entered. By pressing the "Generate" button, this information is sent to the server.

[1125] 3. Check and edit the results

[1126] Review the generated script data and edit it as needed, fine-tuning dialogue and plot points to complete the final script.

[1127] Specific examples

[1128] Below are some specific usage examples.

[1129] 1. The user selects "SF" as the theme of the script and enters "Taro Tanaka, engineer, brave and intelligent" as the character setting.

[1130] 2. The device sends this information to the server.

[1131] 3. The server verifies the information and calls the generative model to generate script elements such as:

[1132] Taro Tanaka: "Our mission is to repair the space station. We don't have much time, so hurry!"

[1133] Plot Point: A space station is severely damaged by a meteorite impact, requiring emergency repairs.

[1134] 4. The server formats the generated content, converts it into a script format, and sends it to the terminal.

[1135] 5. The terminal displays the generated results to the user, who can then check and edit them.

[1136] In this way, screenwriters can easily and efficiently generate high-quality scripts, allowing them to focus on their creative work.

[1137] The processing flow will be explained below.

[1138] Server Processing

[1139] Step 1:

[1140] The server receives requests from users via HTTP requests or WebSockets, which contain information such as the script's theme, character settings, and plot points.

[1141] Step 2:

[1142] The server validates the data it receives, checking that it is valid and contains all the required information, and returns an error message to the user if any data is missing or invalid.

[1143] Step 3:

[1144] With the data successfully validated, the server invokes a generative model, which then inputs this data into the model to generate new script dialogue, plot points, character development, etc.

[1145] Step 4:

[1146] The server formats the raw text returned by the generative model into a screenplay, specifically by organizing the content according to formats such as scene descriptions, dialogues, and character introductions.

[1147] Step 5:

[1148] The formatted script data is sent to the user's device as an HTTP response or WebSocket message.

[1149] Terminal handling

[1150] Step 1:

[1151] The terminal takes input from the user through a GUI, such as the screenplay's theme, character settings, and plot points. This information is entered using forms and select boxes.

[1152] Step 2:

[1153] The device sends the acquired data to the server in the form of an HTTP request. The device sets the necessary headers and parameters and sends the data using the POST method.

[1154] Step 3:

[1155] The terminal receives a response sent from the server, which includes the generated script data.

[1156] Step 4:

[1157] Presents the received script data to the user through a user interface, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[1158] User Action

[1159] Step 1:

[1160] The user inputs information about the script, such as the theme, character settings, and plot points, into the terminal. For example, a sci-fi theme setting and character details can be entered.

[1161] Step 2:

[1162] By pressing the "Generate" button, the user sends a generation request to the server based on the information entered.

[1163] Step 3:

[1164] The user confirms the generated results returned from the server, checks the script data displayed on the terminal, and makes edits or corrections as necessary.

[1165] Step 4:

[1166] Users can save or export their edited script, select the file format and destination, and complete the final script.

[1167] This series of steps allows the user, terminal, and server processes to work together and the script creation process to proceed smoothly.

[1168] Example 1

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

[1170] In conventional scenario creation, manually setting themes, characters, and constructing stories requires time and effort, limiting the scope for creativity. Furthermore, efficient scenario creation is difficult because there is no established method for formatting the generated scenario elements and effectively providing them to users.

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

[1172] In this invention, the server includes means for receiving data such as the scenario theme, character settings, and story main points from the user, means for calling a generation algorithm based on the data to generate new scenario elements, means for formatting the generated content into a scenario format, and means for transmitting the formatted scenario data to the user's device. This enables the efficient generation of high-quality, creative scenarios.

[1173] 1. "User" refers to a person or organization that uses the system to provide data such as the scenario's theme, character settings, and story key points.

[1174] 2. A "scenario" is the overall structure of a story that combines the story's theme, character settings, plot points, etc.

[1175] 3. "Theme" is a concept that indicates the central subject, genre, or setting of a story.

[1176] 4. A "character" is a character who has a specific role within the scenario.

[1177] 5. A "story point" is a point that indicates an important event or development in a story.

[1178] 6. "Data" refers to information received by the system, such as themes, character settings, and story points.

[1179] 7. "Generative Algorithm" refers to artificial intelligence techniques or machine learning models that generate new scenario elements based on provided data.

[1180] 8. "Scenario Elements" are the individual parts that make up a scenario, such as generated dialogue, plot points, character development, etc.

[1181] 9. "Formatting" refers to the process of organizing and converting the generated scenario elements into an appropriate scenario format.

[1182] 10. "Device" means an electronic device, such as a computer, smartphone, or tablet, that a User uses to access the System.

[1183] This invention is a system that receives data such as the scenario theme, character settings, and story key points provided by the user, and uses a generation algorithm to generate new scenario elements based on that data, thereby supporting efficient and creative scenario creation.

[1184] Server Operation

[1185] The server plays a central role and performs the following main tasks:

[1186] 1. Receiving and validating data from the user

[1187] The server receives a request sent by the user. This request contains data such as the scenario's theme, character settings, and story summary. The server first checks whether this data is valid. For example, if the theme or character information is missing, it returns an error message.

[1188] 2. Invoking the generation algorithm

[1189] After receiving valid data, the server invokes a generative algorithm (e.g., an AI technology such as GPT-4) to generate new scenario elements. The algorithm automatically creates dialogue, story points, character development, etc. based on the provided data.

[1190] 3. Formatting the generated data

[1191] The generated scenario elements are in raw text format, so the server formats them into an appropriate scenario format, specifically by arranging and converting the content according to the format of scene descriptions, dialogues, character introductions, etc.

[1192] 4. Sending formatted data

[1193] The formatted scenario data is returned to the user's device. Specifically, the generated results are sent to the user's device using protocols such as HTTP responses or WebSockets.

[1194] Device behavior

[1195] The terminal provides a user interface and is responsible for the following processes:

[1196] 1. Getting User Input

[1197] The terminal collects input from the user about the scenario's theme, character settings, storyline, etc. This input is done through a GUI.

[1198] 2. Submitting a Request

[1199] The acquired data is sent to the server. The device generates an HTTP request and sends it to the server, including the necessary parameters.

[1200] 3. Receiving and Displaying Responses

[1201] It receives the generated results from the server and displays them to the user, providing an interface for the user to edit and modify the displayed data.

[1202] User behavior

[1203] The user performs the following actions:

[1204] 1. Provision of information

[1205] Users input data into the system, such as the scenario's theme, character settings, main points of the story, etc. For example, when creating a science fiction scenario, users might input information such as "engineer, brave, and intelligent" for the characters.

[1206] 2. Sending a generation request

[1207] The user submits a generation request based on the information they entered. By pressing the "Generate" button, this data is sent to the server.

[1208] 3. Check and edit the results

[1209] Check the generated scenario data and edit it as necessary, fine-tuning the dialogue and key points of the story to complete the final scenario.

[1210] Specific examples

[1211] Example

[1212] 1. The user selects "science fiction" as the scenario theme and enters "engineer, brave and intelligent" as the character description.

[1213] 2. The user enters the main point of the story: "A space station is severely damaged by a meteorite impact, requiring emergency repairs."

[1214] 3. The device sends this data to the server.

[1215] 4. The server validates the data and invokes a generation algorithm to generate the following scenario elements:

[1216] Character: "Our mission is to repair the space station. We don't have much time, we have to hurry!"

[1217] Scene description: A space station is severely damaged by a meteorite impact, requiring emergency repairs.

[1218] 5. The server formats the generated content, converts it into a scenario format, and sends it to the terminal.

[1219] 6. The terminal displays the generated results to the user, who can then check and edit them.

[1220] Prompt Sentence Examples

[1221] Theme: Sci-Fi

[1222] Character Profile: Engineer, brave and intelligent

[1223] Summary: A space station is destroyed by a meteorite and requires emergency repairs.

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

[1225] Program processing steps

[1226] Step 1: Collecting User Input

[1227] User behavior

[1228] Through the system's interface, users input data such as the scenario's theme, character settings, and story key points. For example, they can select "science fiction" as the theme, provide "engineer, brave and intelligent" as the character settings, and provide "a space station is destroyed by a meteorite impact and requires emergency repairs" as the story key point.

[1229] input

[1230] The scenario's theme, character settings, and main points of the story.

[1231] output

[1232] Collected user input data.

[1233] Specific actions

[1234] The user enters data into the input fields and clicks the Submit button.

[1235] Step 2: Submitting the request

[1236] Device behavior

[1237] The device sends the data collected from the user to the server as an HTTP request. Specifically, it converts the input data into JSON format and sends it to the server.

[1238] input

[1239] Collected user input data.

[1240] output

[1241] An HTTP request to the server.

[1242] Specific actions

[1243] The terminal generates data in JSON format and sends the data to the server using the HTTP protocol.

[1244] Step 3: Receiving and validating the request

[1245] Server Operation

[1246] The server receives an HTTP request sent by a user. It validates the data contained in the request (theme, character setting, storyline) to ensure it is valid. If any information is missing or invalid, the server generates an error message and sends it to the terminal.

[1247] input

[1248] HTTP request from the user.

[1249] output

[1250] Data that passes validation, or an error message.

[1251] Specific actions

[1252] The server parses the data and performs validation processing.

[1253] Step 4: Invoke the generation algorithm

[1254] Server Operation

[1255] The server then invokes a generation algorithm (e.g., AI technology such as GPT-4) based on the validated data, which generates new scenario elements (dialogue, story points, character development) based on the provided data.

[1256] input

[1257] Data that passed validation.

[1258] output

[1259] Generated scenario elements (dialogue, story points, character development).

[1260] Specific actions

[1261] The server invokes the generation algorithm to generate scenario elements.

[1262] Step 5: Formatting the generated data

[1263] Server Operation

[1264] The server then formats the generated scenario elements into an appropriate scenario format, specifically by arranging and converting the content according to the format of scene descriptions, dialogues, character introductions, etc.

[1265] input

[1266] Generated scenario elements.

[1267] output

[1268] Scenario data formatted in scenario format.

[1269] Specific actions

[1270] The server converts the content into a scenario format and generates formatted data.

[1271] Step 6: Sending formatted data

[1272] Server Operation

[1273] The server sends the formatted scenario data to the user's device. Specifically, it sends the formatted data to the terminal as an HTTP response.

[1274] input

[1275] Scenario data formatted in scenario format.

[1276] output

[1277] The HTTP response to the user's device.

[1278] Specific actions

[1279] The server generates an HTTP response and sends the formatted data.

[1280] Step 7: Review and edit the results

[1281] Device behavior

[1282] The terminal receives the generated results from the server and displays them to the user. The user can check the generated scenario data and edit it as necessary. The user can adjust the dialogue and story points through the interface.

[1283] input

[1284] Generated scenario data received from the server.

[1285] output

[1286] Scenario data displayed to the user, and the results of editing by the user.

[1287] Specific actions

[1288] The terminal analyzes and displays the received data, and the user performs editing operations.

[1289] (Application example 1)

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

[1291] In recent years, the demand for scriptwriting has increased, creating a need for high-quality scripts to be written quickly and efficiently. However, traditional methods require scriptwriters to expend a great deal of time and effort, which can be particularly burdensome when themes, character settings, and plot points are complex. Furthermore, the editing process after script generation is cumbersome, making it difficult to achieve an efficient workflow. To solve these issues, a system that can provide consistent support from script generation to editing is needed.

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

[1293] In this invention, the server includes means for receiving information such as the script theme, character settings, and plot points from the user, means for calling a generative model based on the information and generating new script elements, means for formatting the generated content into a script format, means for transmitting the formatted script data to the user's terminal, and display means for the user to check and edit the generated script data. This allows users to easily generate high-quality scripts and further edit the generated script in real time through an interface. Furthermore, the use of a cloud server allows for rapid large-scale data processing, providing users with a seamless experience.

[1294] A "theme" refers to the main subject or specific content of a script, the central idea that influences the progression of the story.

[1295] "Character settings" include detailed information about the personalities, backgrounds, roles, etc. of the characters who appear in the script.

[1296] A "plot point" is an element that is an important event or turning point in the progression of a story, and forms the basis for the story's development.

[1297] A "generative model" refers to an algorithm or system that uses machine learning or artificial intelligence to automatically generate new script elements based on user-provided information.

[1298] "Script format" refers to the format in which the generated content is organized according to the format of scene descriptions, dialogue, character introductions, etc.

[1299] A "cloud server" refers to a remote server that can be accessed via the Internet and provides large-scale data processing and storage functions.

[1300] "User's terminal" refers to a computer, smartphone, tablet, etc. used by a user, which is a device for receiving and displaying generated script data.

[1301] "Display means" refers to an interface that allows a user to visually check and edit the generated script data.

[1302] "Data validation" is the step where we check whether the information provided by the user is missing or in an invalid format and take appropriate action.

[1303] "Means for making it editable" refers to the ability for users to modify and fine-tune the generated script as needed.

[1304] This invention is a system that receives information such as the theme, character settings, and plot points of a script provided by a user, and generates new script elements using a generative model based on that information. Specific embodiments are described below.

[1305] Server Operation

[1306] The server plays a central role in this system and performs the following main processes:

[1307] 1. Receiving and validating a request:

[1308] The server receives a request sent by a user using the HTTPS protocol. This request contains information such as the script's theme, character settings, and plot points. The server first checks whether this data is valid. For example, if the theme or character information is missing, it returns an error message.

[1309] 2. Invoke the generative model:

[1310] Given valid data, the server invokes a generative model (e.g., a generative AI model like GPT-4) to generate new script elements, such as dialogue, plot points, and character development, automatically based on the information provided.

[1311] 3. Formatting content:

[1312] The generated script elements are in raw text format, so the server formats them into a script, specifically by organizing the content according to the format of scene descriptions, dialogues, character introductions, etc.

[1313] 4. Sending the response:

[1314] The formatted script data is sent to the user's device. Specifically, the generated results are sent to the user's device via HTTP response or WebSocket.

[1315] Device behavior

[1316] The terminal provides the user interface and is responsible for the following:

[1317] 1. Getting user input:

[1318] The terminal collects input from the user about the script's theme, character settings, plot points, etc. This input is done through a GUI.

[1319] 2. Submit your request:

[1320] The acquired input data is sent to the server. The terminal generates an HTTPS request and sends it to the server, including the necessary parameters.

[1321] 3. Receiving and Displaying Responses:

[1322] It receives the generated results from the server and displays them to the user, providing an interface for the user to edit and modify the displayed data.

[1323] User behavior

[1324] The user performs the following actions:

[1325] 1. Provision of information:

[1326] Users input information about the script's theme, character settings, plot points, etc. For example, if creating a sci-fi script, they input information about the character, such as "engineer, brave, and intelligent."

[1327] 2. Send the generation request:

[1328] The user submits a generation request based on the information they entered. By pressing the "Generate" button, this information is sent to the server.

[1329] 3. Review and edit the results:

[1330] Review the generated script data and edit it as needed, fine-tuning dialogue and plot points to complete the final script.

[1331] Specific examples

[1332] Let's consider a specific example of a movie production company using this system. The theme is "Tokyo of the future," the character is a "police officer of the future with a very keen intuition," and the plot point is a "mysterious disappearance." The following prompt is sent to the generative AI model:

[1333] Example prompt sentence:

[1334] Theme: Future Tokyo

[1335] Character: A police officer from the future with a keen intuition

[1336] Plot Point: Mysterious Disappearance

[1337] Generated script elements please.

[1338] As described above, this invention allows users to easily generate high-quality scripts and then edit the generated scripts in real time through an interface. Furthermore, by using a cloud server, large-scale data processing can be performed quickly, providing users with a seamless experience.

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

[1340] Step 1:

[1341] The user inputs information such as the script's theme, character settings, and plot points through the device's user interface. This information is collected as input data. The input includes specific details such as the theme being "Tokyo of the future," the character setting being "a police officer of the future with a very keen intuition," and the plot point being "a mysterious disappearance."

[1342] Step 2:

[1343] The device sends the collected input data to the server as an HTTPS request, which includes the user's input such as theme, character settings, and plot points.

[1344] Step 3:

[1345] The server validates the data of the received request. This validation process checks whether the data is complete and not invalid. For example, if character information is missing, an error message is generated and returned to the user. The input of this step is the input data from the user, and the output is the validation result.

[1346] Step 4:

[1347] Once valid data is verified, the server invokes a generative AI model (e.g., GPT-4). The generative AI model generates new script elements based on the provided theme, character settings, and plot points. The input is the validated data, and the output is the generated script elements. For example, a script element might be generated such as "A police officer from the future investigates a mysterious disappearance in Tokyo."

[1348] Step 5:

[1349] The generated script elements are returned to the server in raw text format, which the server then formats into a user-friendly script. Specifically, the script is organized according to the format of scene descriptions, dialogues, character introductions, etc. The input of this step is the generated raw text, and the output is formatted script data.

[1350] Step 6:

[1351] The server generates an HTTP response to send the formatted script data to the user's terminal. This response is used as a display means for the user to check and edit. The input is the formatted script data, and the output is the data to be sent to the user's terminal.

[1352] Step 7:

[1353] The terminal displays the script data received from the server. The user reviews this data and makes edits as needed, for example, fine-tuning the dialogue in the generated script or adding plot points. The input is the data received from the server, and the output is the data displayed and edited in the user interface.

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

[1355] This invention is a system that uses a generative model to generate new script elements based on information provided by the user, such as the script's theme, character settings, and plot points, and also combines it with an emotion engine that recognizes the user's emotions and customizes the script content, making it possible to generate more personalized scripts.

[1356] Server Operation

[1357] The server receives a request from the user and performs the following process:

[1358] 1. Receiving and Validating a Request

[1359] The server receives information about the script submitted by the user, such as themes, characterization, plot points, etc. It also checks that the received data is valid and contains all the required information, and returns an error message to the user if any data is missing or invalid.

[1360] 2. Emotion engine activation and analysis

[1361] The server activates an emotion engine and analyzes the user's input data and user interface operation history to recognize the user's emotions, such as the speed at which the text is entered, the content of the input, and the frequency and strength of clicks.

[1362] 3. Invoking the Generative Model

[1363] Based on the recognized emotions, a generative model is invoked, which generates customized dialogue, plot points, character development, etc. based on the user's emotions and the information provided.

[1364] 4. Content Formatting

[1365] The generated script elements are formatted into a script according to the format of scene descriptions, dialogues, character introductions, etc.

[1366] 5. Sending the Response

[1367] The formatted script data is sent to the user's device. The generated script is customized based on the user's emotions, resulting in a more personalized content.

[1368] Device behavior

[1369] The terminal provides a user interface and performs the following processes:

[1370] 1. Getting User Input

[1371] The device gets input from the user about the screenplay's themes, characterization, plot points, etc. For example, it uses forms and select boxes to collect information.

[1372] 2. Collecting Emotional Data

[1373] The device collects data such as the user's typing speed, text content, and click frequency, and passes this information to an emotion engine, which analyzes the user's emotions in real time.

[1374] 3. Submitting a Request

[1375] The acquired input data and emotion data are sent to the server as an HTTP request.

[1376] 4. Receiving and Displaying Responses

[1377] Receives customized script data sent from the server and displays it to the user, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[1378] User Actions

[1379] The user performs the following operations:

[1380] 1. Provision of information

[1381] The user inputs information about the script, such as the theme, character settings, and plot points, into the system. For example, the user inputs a sci-fi theme setting and character details.

[1382] 2. Submitting a Request

[1383] By pressing the "Generate" button, the user sends a generation request to the server based on the input information and the emotion data collected by the device.

[1384] 3. Check and edit the results

[1385] Review the customized script data and make edits and revisions as needed, fine-tuning dialogue, plot points, etc., to complete the final script.

[1386] Specific examples

[1387] As a concrete use case, consider a user writing a science fiction-themed screenplay. The user enters the following information:

[1388] Theme: Sci-Fi

[1389] Character Description: "Taro Tanaka, engineer, brave and intelligent"

[1390] Plot Point: "A space station is severely damaged by a meteorite impact and requires emergency repairs."

[1391] While the user is typing, the emotion engine analyzes their typing speed and click strength to determine if they are impatient. The server then uses a generative model to generate a script that reflects the user's emotions. For example, the tone of the dialogue may be adjusted to create a more tense atmosphere.

[1392] The generated script looks like this:

[1393] Taro Tanaka: "Our mission is to repair the space station. We don't have much time, so hurry!"

[1394] Finally, the server formats the customized script and sends it to the user's device, where the user can review and edit it to complete the final script.

[1395] In this way, by combining emotion engines, more personalized script generation based on the user's emotions can be achieved.

[1396] The processing flow will be explained below.

[1397] Server Processing

[1398] Step 1:

[1399] The server receives requests from users via HTTP requests, WebSockets, etc. The requests contain information such as the script's theme, character settings, and plot points.

[1400] Step 2:

[1401] The server validates the received data, checking whether enough theme and character information has been provided or if any information is missing, and returns an error message to the user if any data is missing or invalid.

[1402] Step 3:

[1403] The server activates an emotion engine and analyzes the user's input data and the user interface operation history to recognize the user's emotion, such as input speed, input content, click frequency and intensity, etc.

[1404] Step 4:

[1405] Based on the emotion data recognized by the emotion engine, a generative model is invoked, which generates new script elements (dialogue, plot points, character development, etc.) based on the user's emotions and the information provided.

[1406] Step 5:

[1407] The generated content is formatted into a script, specifically by organizing the content according to a format such as scene descriptions, dialogue, and character introductions.

[1408] Step 6:

[1409] The formatted script data is sent to the user's device as an HTTP response or WebSocket message.

[1410] Terminal handling

[1411] Step 1:

[1412] The terminal receives input from the user through a GUI, such as the script's theme, character settings, and plot points. The input is collected using forms and select boxes.

[1413] Step 2:

[1414] The device collects data such as the user's typing speed, text content, and click frequency and intensity, and passes this data to the emotion engine. This data is collected in real time as you type.

[1415] Step 3:

[1416] The acquired input data and emotion data are sent to the server in the form of an HTTP request, with appropriate headers and parameters set.

[1417] Step 4:

[1418] The terminal receives the response sent from the server, which includes the generated customized script data.

[1419] Step 5:

[1420] Presents the received script data to the user through a user interface, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[1421] User behavior

[1422] Step 1:

[1423] The user inputs information about the script, such as the theme, character settings, and plot points, into the terminal. For example, the user inputs a sci-fi theme or character details.

[1424] Step 2:

[1425] The user presses the "Generate" button to send a generation request to the server based on the input information and the emotion data collected by the device.

[1426] Step 3:

[1427] The user confirms the customized script data returned from the server, checks the script data displayed on the terminal, and makes edits or corrections as necessary.

[1428] Step 4:

[1429] Users can save or export their edited script, select the file format and destination, and complete the final script.

[1430] This series of steps allows the user, device, and server processes to work together to smoothly advance the script generation process. Customization based on the user's emotions results in a more personalized script.

[1431] Example 2

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

[1433] Conventional script generation systems were able to generate and format script elements based on information received from users, but they were unable to generate personalized scripts that took the user's emotions into account. Because they were unable to create dialogue or set scenes that reflected the user's emotions, it was difficult to create a script that reflected each individual's emotions and intentions during the creative process.

[1434] The specific processing by the specific processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes means for receiving information such as the theme, character settings, and plot points of the script from the user, means for calling a generative model based on the information and generating new script elements, means for formatting the generated content into a script format, means for sending the formatted script data to the user's terminal, means for activating an emotion engine that recognizes the user's emotions and analyzing the user's input data and operation history, and means for customizing the generative model based on the recognized emotions. This makes it possible to generate a script personalized according to the user's emotions.

[1435] A "user" is an entity that uses the system to provide information such as the theme, character settings, and plot points of a script and receives the generated script.

[1436] A "server" is a computer device that receives requests from users and performs a series of processes such as generating, formatting, and transmitting a script.

[1437] "Theme" is information that defines the basic subject matter and genre of the entire script.

[1438] "Character settings" are information that defines the detailed characteristics and roles of the characters that appear in the script.

[1439] A "plot point" is information that indicates an important event or turning point in the progression of a script.

[1440] A "generative model" is an algorithm or program for generating new script elements based on user-provided information.

[1441] "Script elements" are various pieces of content such as dialogue, scene descriptions, and character details that are generated by a generative model.

[1442] An "emotion engine" is a software component that analyzes a user's input data and operation history to recognize emotions.

[1443] "Emotional data" is information such as typing speed, click frequency, and content that is collected to reflect a user's emotions.

[1444] "Formatting" is the process of organizing the generated script elements into a format such as scene descriptions, dialogue, and character introductions.

[1445] An "HTTP request" is a communication format that follows a protocol for sending information from a user's terminal to a server.

[1446] A "prompt sentence" is data in the form of a specific document that is input to a generative model.

[1447] This invention relates to a system that generates new script elements based on information such as themes, character settings, and plot points of a script provided by a user, and also recognizes the user's emotions to personalize the script content. Specific methods for implementing this system are described below.

[1448] Server Operation

[1449] The server uses several software components to process the script generation. First, the server receives the HTTP request sent by the user. This request contains information about the script's theme, character settings, plot points, etc. The server validates the received information to ensure that all required data is present.

[1450] Next, the server launches the emotion engine, which uses a software library called "EmotionalAnalyzer.dll" to analyze the user's input data and operation history (input speed, click frequency, etc.) to recognize the user's emotions. This allows the server to understand the user's emotional state, such as whether they are anxious or relaxed.

[1451] The server then invokes the generative AI model, implemented in the file "ScriptGenerator.ai," which takes emotion data and user-provided data in the form of a prompt. For example, it generates the following prompt:

[1452] "Theme: Sci-Fi, Character: Tanaka Taro, engineer, brave and intelligent, Plot point: A space station is destroyed by a meteorite and requires emergency repairs. Generate tense dialogue that takes into account the user's impatience."

[1453] The generative AI model generates new script elements based on this prompt.

[1454] The generated script elements are formatted into a script using "ScriptFormatter.dll", for example, into scene descriptions, dialogues, character introductions, etc.

[1455] Finally, the formatted script data is sent to the user's device as an HTTP response.

[1456] Device behavior

[1457] The terminal provides a user interface and takes input from the user about the screenplay's theme, character settings, plot points, etc. This input is done through forms and select boxes and stored in a variable, for example "themeInput.value".

[1458] In addition, the device collects data such as the user's typing speed and click frequency in real time and converts it into a format that can be passed to the emotion engine, allowing the server to recognize the user's emotions.

[1459] When the user completes all input and clicks the "Generate" button, the device sends the input data and emotion data to the server as a single HTTP request.

[1460] After receiving the HTTP response from the server, the device displays the received script data to the user in an appropriate format. For example, the dialogue portion is displayed as "quoteElement.innerHTML".

[1461] User Actions

[1462] The user inputs information about the script, such as the theme, character settings, and plot points of the script into the system. For example, they input a sci-fi theme and character details. After completing all the input, the user clicks the "Generate" button to send the request to the server.

[1463] The generated script data is reviewed and, if necessary, the dialogue, scenes, etc. are edited. Finally, the user creates a completed script using a tool such as a text editor.

[1464] In this way, by combining emotion engines, more personalized script generation based on the user's emotions can be achieved.

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

[1466] Step 1:

[1467] Receiving and Validating a Request

[1468] 1. The server receives an HTTP request sent by the user.

[1469] Input: An HTTP request containing information about the screenplay's theme, characterization, plot points, etc.

[1470] Output: Various extracted information.

[1471] 2. The server extracts the received data and checks for missing information or invalid formats.

[1472] Data processing: Checking themes and character settings, and validating that all necessary information is available.

[1473] Behavior: If validation fails, an error message is generated and returned to the user.

[1474] Step 2:

[1475] Emotion engine activation and analysis

[1476] 1. The server starts the emotion engine.

[1477] Input: Extracted user input data and operation history (typing speed, click frequency, etc.).

[1478] Output: The user's emotional state.

[1479] 2. The emotion engine analyzes the input data and recognizes the user's emotions.

[1480] Data calculations: Sentiment analysis using text entry speed, click frequency, and input content.

[1481] How it works: The emotion engine uses the data to determine the user's emotional state, such as whether they are anxious.

[1482] Step 3:

[1483] Invoking the generative model

[1484] 1. The server invokes the generative AI model based on the emotions recognized by the emotion engine.

[1485] Input: User emotional data, script themes, characterization, and plot points.

[1486] Output: The newly generated script element.

[1487] 2. The server converts this data into prompt sentence format and inputs it into the generative model.

[1488] Data processing: Prompt sentence generation.

[1489] How it works: The generative AI model generates new script elements based on the prompt. For example, it generates the following prompt:

[1490] "Theme: Sci-Fi, Character: Tanaka Taro, engineer, brave and intelligent, Plot point: A space station is destroyed by a meteorite and requires emergency repairs. Generate tense dialogue that takes into account the user's impatience."

[1491] Step 4:

[1492] Content Formatting

[1493] 1. The server formats the script elements received from the generative model into a script format.

[1494] Input: Generated script elements.

[1495] Output: Formatted script data.

[1496] 2. The server uses "ScriptFormatter.dll" to organize the generated elements into formats such as scene descriptions, dialogues, character introductions, etc.

[1497] Data processing: Formatting various script elements into a specified format.

[1498] Step 5:

[1499] Sending a response

[1500] 1. The server sends the formatted script data to the user's device as an HTTP response.

[1501] Input: Formatted script data.

[1502] Output: The HTTP response sent to the user's device.

[1503] Step 6:

[1504] Getting User Input

[1505] 1. The device obtains information such as theme, character settings, and plot points through the user interface.

[1506] Input: User-supplied themes, characterizations, and plot points.

[1507] Output: User input data stored on the device.

[1508] 2. The device stores the collected data in a variable, for example, "themeInput.value".

[1509] Behavior: Provides input forms and select boxes.

[1510] Step 7:

[1511] Collecting Emotional Data

[1512] 1. The device collects emotional data such as the user's text input speed, click frequency, and input content.

[1513] Input: User operation data.

[1514] Output: Collected emotion data.

[1515] 2. The device converts this data into a format that can be passed to the emotion engine and stores it in variables.

[1516] Step 8:

[1517] Submitting a Request

[1518] 1. The device sends the collected user input data and emotion data together as an HTTP request to the server.

[1519] Input: Collected user input data and sentiment data.

[1520] Output: The HTTP request sent to the server.

[1521] Step 9:

[1522] Receiving and displaying the response

[1523] 1. The terminal receives the HTTP response returned from the server.

[1524] Input: The HTTP response from the server.

[1525] Output: Received script data.

[1526] 2. The terminal displays the received script data in an appropriate format for the user.

[1527] Behavior: The dialogue is displayed as "quoteElement.innerHTML".

[1528] (Application example 2)

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

[1530] Conventional script generation systems have difficulty identifying user emotions and reflecting them in the script content, which has led to the issue of insufficient script generation personalized for each user. Therefore, there is a need for a method to generate scripts that are more individualized and in line with emotions by generating scripts based on the user's emotions.

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

[1532] In this invention, the server includes means for receiving information such as the theme, character settings, and plot points of the script from the user, means for calling a generative model based on the information and generating new script elements, means for formatting the generated content into a script format, means for sending the formatted script data to the user's terminal, means for collecting the user's input speed and click strength, means for analyzing the collected data to recognize the user's emotions, and means for customizing the generative model according to the emotions. This enables more personalized script generation by analyzing the user's emotions in real time and customizing the script content based on that.

[1533] "Means for receiving information from a user about the screenplay's theme, character settings, plot points, etc." refers to a device or software that provides an interface for a user to input the screenplay's theme, character details, and major plot points.

[1534] The "means for invoking a generative model based on the information and generating new script elements" refers to an algorithm or software module for using artificial intelligence to generate new scenario elements based on the acquired user information.

[1535] "Means for formatting the generated content into a script" refers to a device or software that organizes the generated scenario elements, such as dialogue, scene descriptions, and character introductions, according to a standard scenario format and converts them into an appropriate format.

[1536] "Means for transmitting formatted script data to a user's terminal" refers to a communication device or software for transmitting script data to a device used by a user (e.g., a smartphone or a PC).

[1537] "Means for collecting user typing speed and click intensity" refers to sensors or software for collecting operation data such as a user's typing speed and click frequency and intensity in real time.

[1538] "Means for recognizing user emotions by analyzing collected data" refers to algorithms or software for analyzing collected operation data and determining the user's emotional state (e.g., excitement, tension, relief).

[1539] The "means for customizing generative models according to emotions" is a software module for adjusting the scenario generation algorithm and model output content based on the recognized user emotions.

[1540] This invention is a system that uses a generative model to personalize the theme, character settings, plot points, etc. of a script based on the user's emotions, and provides them through a user interface. Specific embodiments for implementing this invention are described below.

[1541] Server Operation

[1542] The server contains various software modules that perform functions such as:

[1543] 1. Receiving and Validating a Request

[1544] The server receives information about the script submitted by the user, such as themes, characterization, plot points, etc. It also checks that the received data is valid and contains all the required information, and returns an error message to the user if any data is missing or invalid.

[1545] 2. Emotion engine activation and analysis

[1546] The server starts an emotion engine (e.g., SentimentAnalyzer) and analyzes the user's input data and user interface operation history to recognize the user's emotion, such as the speed at which the text is entered, the content of the input, and the frequency and strength of clicks.

[1547] 3. Invoking the Generative Model

[1548] Based on the recognized emotion, a generative AI model (e.g., AIGenerator) is invoked, which generates customized dialogue, plot points, character development, etc. based on the user's emotion and the provided information.

[1549] 4. Content Formatting

[1550] The generated script elements are formatted into a script according to the format of scene descriptions, dialogues, character introductions, etc.

[1551] 5. Sending the Response

[1552] The formatted script data is sent to the user's device. The generated script is customized based on the user's emotions, resulting in a more personalized content.

[1553] Device behavior

[1554] The terminal provides a user interface and performs the following tasks:

[1555] 1. Getting User Input

[1556] The device gets input from the user about the screenplay's themes, characterization, plot points, etc. For example, it uses forms and select boxes to collect information.

[1557] 2. Collecting Emotional Data

[1558] The device collects data such as the user's typing speed, text content, and click frequency, and passes this information to an emotion engine, which analyzes the user's emotions in real time.

[1559] 3. Submitting a Request

[1560] The acquired input data and emotion data are sent to the server as an HTTP request.

[1561] 4. Receiving and Displaying Responses

[1562] Receives customized script data sent from the server and displays it to the user, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[1563] User Actions

[1564] The user does the following:

[1565] 1. Provision of information

[1566] The user inputs information about the script, such as the theme, character settings, and plot points, into the system. For example, the user inputs a sci-fi theme setting and character details.

[1567] 2. Submitting a Request

[1568] By pressing the "Generate" button, the user sends a generation request to the server based on the input information and the emotion data collected by the device.

[1569] 3. Check and edit the results

[1570] Review the customized script data and make edits and revisions as needed, fine-tuning dialogue, plot points, etc., to complete the final script.

[1571] Specific examples

[1572] As a concrete use case, consider a user writing a sci-fi themed screenplay. The user enters the following information:

[1573] Enter the theme of the scenario: SF

[1574] Enter your character's profile: Taro Tanaka, an engineer, brave and intelligent

[1575] Enter the plot point: A space station is destroyed by a meteorite impact and requires emergency repairs.

[1576] When a user enters the above information, the emotion engine detects impatience, and the generative AI model changes the dialogue accordingly to make it more urgent, for example, "Taro Tanaka: 'Our mission is to repair the space station. We don't have time, so hurry!'"

[1577] The system configuration described above makes it possible to generate a personalized script that reflects the user's emotions.

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

[1579] Step 1:

[1580] The user enters information about the script, such as themes, character settings, and plot points.

[1581] Input: User inputs theme "science fiction", character description "Taro Tanaka, engineer, brave and intelligent", and plot point "A space station is destroyed by a meteorite impact, requiring emergency repairs."

[1582] Output: Sends these inputs to the terminal.

[1583] Step 2:

[1584] The device collects additional data, such as the user's typing speed and click strength.

[1585] Input: User input behavior (typing speed, click strength)

[1586] Output: Collected typing speed and click strength data is saved on the device.

[1587] Step 3:

[1588] The device sends the collected information (script information, input speed, and click strength) to the server as an HTTP request.

[1589] Input: Theme, character preference, and plot point information entered by the user, as well as collected typing speed and click intensity data

[1590] Output: HTTP request sent to the server

[1591] Step 4:

[1592] Validates requests received by the server, checking for missing information or invalid formats.

[1593] Input: Screenplay information and related data received by the server

[1594] Output: Error message if there is an error, otherwise proceed to the next step

[1595] Step 5:

[1596] The server activates an emotion engine and analyzes the user's input data and operation data to recognize emotions.

[1597] Input: User interaction data, such as typing speed and click strength

[1598] Output: Analyzed user emotion data (e.g., impatience, excitement)

[1599] Step 6:

[1600] The server invokes a generative AI model to generate new script elements based on the user's emotions and input information.

[1601] Input: User theme, characterization, plot point information, and parsed emotional data

[1602] Output: New script elements based on emotions

[1603] Step 7:

[1604] The server formats the generated script elements into a standard script format.

[1605] Input: Generated script elements

[1606] Output: Formatted scenario data (e.g., dialogue and scene descriptions)

[1607] Step 8:

[1608] The server sends the formatted scenario data to the user's device.

[1609] Input: Formatted scenario data

[1610] Output: Scenario data sent to the user's device

[1611] Step 9:

[1612] The user checks the customized script data received on the device and edits or corrects it as necessary.

[1613] Input: Formatted scenario data

[1614] Output: A script finalized by the user

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

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

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

[1618] [Fourth embodiment]

[1619] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

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

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

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

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

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

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

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

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

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

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

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

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

[1632] This invention is a system that receives information such as themes, character settings, and plot points of a script provided by the user, and generates new script elements using a generative model based on that information, thereby supporting efficient and creative scriptwriting.

[1633] Server Operation

[1634] The server plays a central role and performs the following main tasks:

[1635] 1. Receiving and Validating a Request

[1636] The server receives a request sent by a user. This request contains information such as the theme, character settings, and plot points of the script. The server first checks whether this data is valid. For example, if the theme or character information is missing, it returns an error message.

[1637] 2. Invoking the Generative Model

[1638] After receiving valid data, the server invokes a generative model (e.g., a machine learning model or AI algorithm) to generate new script elements. The model automatically creates dialogue, plot points, character development, etc. based on the information provided.

[1639] 3. Formatting Content

[1640] The generated script elements are in raw text format, so the server formats them into a script, specifically by organizing the content according to the format of scene descriptions, dialogues, character introductions, etc.

[1641] 4. Sending the Response

[1642] The formatted script data is returned to the user. Specifically, the generated results are sent to the user's device via an HTTP response or WebSocket.

[1643] Device behavior

[1644] The terminal provides the user interface and is responsible for the following:

[1645] 1. Getting User Input

[1646] The terminal collects input from the user about the script's theme, character settings, plot points, etc. This input is done through a GUI.

[1647] 2. Submitting a Request

[1648] The acquired input data is sent to the server. The terminal generates an HTTP request and sends it to the server, including the necessary parameters.

[1649] 3. Receiving and Displaying Responses

[1650] It receives the generated results from the server and displays them to the user, providing an interface for the user to edit and modify the displayed data.

[1651] User behavior

[1652] The user performs the following actions:

[1653] 1. Provision of information

[1654] Users input information about the script's theme, character settings, plot points, etc. For example, when creating a sci-fi script, they input information about the character, such as "Taro Tanaka, engineer, brave and intelligent."

[1655] 2. Sending a generation request

[1656] The user submits a generation request based on the information they entered. By pressing the "Generate" button, this information is sent to the server.

[1657] 3. Check and edit the results

[1658] Review the generated script data and edit it as needed, fine-tuning dialogue and plot points to complete the final script.

[1659] Specific examples

[1660] Below are some specific usage examples.

[1661] 1. The user selects "SF" as the theme of the script and enters "Taro Tanaka, engineer, brave and intelligent" as the character setting.

[1662] 2. The device sends this information to the server.

[1663] 3. The server verifies the information and calls the generative model to generate script elements such as:

[1664] Taro Tanaka: "Our mission is to repair the space station. We don't have much time, so hurry!"

[1665] Plot Point: A space station is severely damaged by a meteorite impact, requiring emergency repairs.

[1666] 4. The server formats the generated content, converts it into a script format, and sends it to the terminal.

[1667] 5. The terminal displays the generated results to the user, who can then check and edit them.

[1668] In this way, screenwriters can easily and efficiently generate high-quality scripts, allowing them to focus on their creative work.

[1669] The processing flow will be explained below.

[1670] Server Processing

[1671] Step 1:

[1672] The server receives requests from users via HTTP requests or WebSockets, which contain information such as the script's theme, character settings, and plot points.

[1673] Step 2:

[1674] The server validates the data it receives, checking that it is valid and contains all the required information, and returns an error message to the user if any data is missing or invalid.

[1675] Step 3:

[1676] With the data successfully validated, the server invokes a generative model, which then inputs this data into the model to generate new script dialogue, plot points, character development, etc.

[1677] Step 4:

[1678] The server formats the raw text returned by the generative model into a screenplay, specifically by organizing the content according to formats such as scene descriptions, dialogues, and character introductions.

[1679] Step 5:

[1680] The formatted script data is sent to the user's device as an HTTP response or WebSocket message.

[1681] Terminal handling

[1682] Step 1:

[1683] The terminal takes input from the user through a GUI, such as the screenplay's theme, character settings, and plot points. This information is entered using forms and select boxes.

[1684] Step 2:

[1685] The device sends the acquired data to the server in the form of an HTTP request. The device sets the necessary headers and parameters and sends the data using the POST method.

[1686] Step 3:

[1687] The terminal receives a response sent from the server, which includes the generated script data.

[1688] Step 4:

[1689] Presents the received script data to the user through a user interface, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[1690] User Action

[1691] Step 1:

[1692] The user inputs information about the script, such as the theme, character settings, and plot points, into the terminal. For example, a sci-fi theme setting and character details can be entered.

[1693] Step 2:

[1694] By pressing the "Generate" button, the user sends a generation request to the server based on the information entered.

[1695] Step 3:

[1696] The user confirms the generated results returned from the server, checks the script data displayed on the terminal, and makes edits or corrections as necessary.

[1697] Step 4:

[1698] Users can save or export their edited script, select the file format and destination, and complete the final script.

[1699] This series of steps allows the user, terminal, and server processes to work together and the script creation process to proceed smoothly.

[1700] Example 1

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

[1702] In conventional scenario creation, manually setting themes, characters, and constructing stories requires time and effort, limiting the scope for creativity. Furthermore, efficient scenario creation is difficult because there is no established method for formatting the generated scenario elements and effectively providing them to users.

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

[1704] In this invention, the server includes means for receiving data such as the scenario theme, character settings, and story main points from the user, means for calling a generation algorithm based on the data to generate new scenario elements, means for formatting the generated content into a scenario format, and means for transmitting the formatted scenario data to the user's device. This enables the efficient generation of high-quality, creative scenarios.

[1705] 1. "User" refers to a person or organization that uses the system to provide data such as the scenario's theme, character settings, and story key points.

[1706] 2. A "scenario" is the overall structure of a story that combines the story's theme, character settings, plot points, etc.

[1707] 3. "Theme" is a concept that indicates the central subject, genre, or setting of a story.

[1708] 4. A "character" is a character who has a specific role within the scenario.

[1709] 5. A "story point" is a point that indicates an important event or development in a story.

[1710] 6. "Data" refers to information received by the system, such as themes, character settings, and story points.

[1711] 7. "Generative Algorithm" refers to artificial intelligence techniques or machine learning models that generate new scenario elements based on provided data.

[1712] 8. "Scenario Elements" are the individual parts that make up a scenario, such as generated dialogue, plot points, character development, etc.

[1713] 9. "Formatting" refers to the process of organizing and converting the generated scenario elements into an appropriate scenario format.

[1714] 10. "Device" means an electronic device, such as a computer, smartphone, or tablet, that a User uses to access the System.

[1715] This invention is a system that receives data such as the scenario theme, character settings, and story key points provided by the user, and uses a generation algorithm to generate new scenario elements based on that data, thereby supporting efficient and creative scenario creation.

[1716] Server Operation

[1717] The server plays a central role and performs the following main tasks:

[1718] 1. Receiving and validating data from the user

[1719] The server receives a request sent by the user. This request contains data such as the scenario's theme, character settings, and story summary. The server first checks whether this data is valid. For example, if the theme or character information is missing, it returns an error message.

[1720] 2. Invoking the generation algorithm

[1721] After receiving valid data, the server invokes a generative algorithm (e.g., an AI technology such as GPT-4) to generate new scenario elements. The algorithm automatically creates dialogue, story points, character development, etc. based on the provided data.

[1722] 3. Formatting the generated data

[1723] The generated scenario elements are in raw text format, so the server formats them into an appropriate scenario format, specifically by arranging and converting the content according to the format of scene descriptions, dialogues, character introductions, etc.

[1724] 4. Sending formatted data

[1725] The formatted scenario data is returned to the user's device. Specifically, the generated results are sent to the user's device using protocols such as HTTP responses or WebSockets.

[1726] Device behavior

[1727] The terminal provides a user interface and is responsible for the following processes:

[1728] 1. Getting User Input

[1729] The terminal collects input from the user about the scenario's theme, character settings, storyline, etc. This input is done through a GUI.

[1730] 2. Submitting a Request

[1731] The acquired data is sent to the server. The device generates an HTTP request and sends it to the server, including the necessary parameters.

[1732] 3. Receiving and Displaying Responses

[1733] It receives the generated results from the server and displays them to the user, providing an interface for the user to edit and modify the displayed data.

[1734] User behavior

[1735] The user performs the following actions:

[1736] 1. Provision of information

[1737] The user inputs data such as the scenario's theme, character settings, and main points of the story into the system. For example, when creating a science fiction scenario, the user might input information such as "engineer, brave, and intelligent" for the characters.

[1738] 2. Sending a generation request

[1739] The user submits a generation request based on the information they entered. By pressing the "Generate" button, this data is sent to the server.

[1740] 3. Check and edit the results

[1741] Check the generated scenario data and edit it as necessary, fine-tuning the dialogue and key points of the story to complete the final scenario.

[1742] Specific examples

[1743] Example

[1744] 1. The user selects "science fiction" as the scenario theme and enters "engineer, brave and intelligent" as the character description.

[1745] 2. The user enters the main point of the story: "A space station is severely damaged by a meteorite impact, requiring emergency repairs."

[1746] 3. The device sends this data to the server.

[1747] 4. The server validates the data and invokes a generation algorithm to generate the following scenario elements:

[1748] Character: "Our mission is to repair the space station. We don't have much time, we have to hurry!"

[1749] Scene description: A space station is severely damaged by a meteorite impact, requiring emergency repairs.

[1750] 5. The server formats the generated content, converts it into a scenario format, and sends it to the terminal.

[1751] 6. The terminal displays the generated results to the user, who can then check and edit them.

[1752] Prompt Sentence Examples

[1753] Theme: Sci-Fi

[1754] Character Profile: Engineer, brave and intelligent

[1755] Summary: A space station is destroyed by a meteorite and requires emergency repairs.

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

[1757] Program processing steps

[1758] Step 1: Collecting User Input

[1759] User behavior

[1760] Through the system's interface, users input data such as the scenario's theme, character settings, and story key points. For example, they can select "science fiction" as the theme, provide "engineer, brave and intelligent" as the character settings, and provide "a space station is destroyed by a meteorite impact and requires emergency repairs" as the story key point.

[1761] input

[1762] The scenario's theme, character settings, and main points of the story.

[1763] output

[1764] Collected user input data.

[1765] Specific actions

[1766] The user enters data into the input fields and clicks the Submit button.

[1767] Step 2: Submitting the request

[1768] Device behavior

[1769] The device sends the data collected from the user to the server as an HTTP request. Specifically, it converts the input data into JSON format and sends it to the server.

[1770] input

[1771] Collected user input data.

[1772] output

[1773] An HTTP request to the server.

[1774] Specific actions

[1775] The terminal generates data in JSON format and sends the data to the server using the HTTP protocol.

[1776] Step 3: Receiving and validating the request

[1777] Server Operation

[1778] The server receives an HTTP request sent by a user. It validates the data contained in the request (theme, character setting, storyline) to ensure it is valid. If any information is missing or invalid, the server generates an error message and sends it to the terminal.

[1779] input

[1780] HTTP request from the user.

[1781] output

[1782] Data that passes validation, or an error message.

[1783] Specific actions

[1784] The server parses the data and performs validation processing.

[1785] Step 4: Invoke the generation algorithm

[1786] Server Operation

[1787] The server then invokes a generation algorithm (e.g., AI technology such as GPT-4) based on the validated data, which generates new scenario elements (dialogue, story points, character development) based on the provided data.

[1788] input

[1789] Data that passed validation.

[1790] output

[1791] Generated scenario elements (dialogue, story points, character development).

[1792] Specific actions

[1793] The server invokes the generation algorithm to generate scenario elements.

[1794] Step 5: Formatting the generated data

[1795] Server Operation

[1796] The server then formats the generated scenario elements into an appropriate scenario format, specifically by arranging and converting the content according to the format of scene descriptions, dialogues, character introductions, etc.

[1797] input

[1798] Generated scenario elements.

[1799] output

[1800] Scenario data formatted in scenario format.

[1801] Specific actions

[1802] The server converts the content into a scenario format and generates formatted data.

[1803] Step 6: Sending formatted data

[1804] Server Operation

[1805] The server sends the formatted scenario data to the user's device. Specifically, it sends the formatted data to the terminal as an HTTP response.

[1806] input

[1807] Scenario data formatted in scenario format.

[1808] output

[1809] The HTTP response to the user's device.

[1810] Specific actions

[1811] The server generates an HTTP response and sends the formatted data.

[1812] Step 7: Review and edit the results

[1813] Device behavior

[1814] The terminal receives the generated results from the server and displays them to the user. The user can check the generated scenario data and edit it as necessary. The user can adjust the dialogue and story points through the interface.

[1815] input

[1816] Generated scenario data received from the server.

[1817] output

[1818] Scenario data displayed to the user, and the results of editing by the user.

[1819] Specific actions

[1820] The terminal analyzes and displays the received data, and the user performs editing operations.

[1821] (Application example 1)

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

[1823] In recent years, the demand for scriptwriting has increased, creating a need for high-quality scripts to be written quickly and efficiently. However, traditional methods require scriptwriters to expend a great deal of time and effort, which can be particularly burdensome when themes, character settings, and plot points are complex. Furthermore, the editing process after script generation is cumbersome, making it difficult to achieve an efficient workflow. To solve these issues, a system that can provide consistent support from script generation to editing is needed.

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

[1825] In this invention, the server includes means for receiving information such as the script theme, character settings, and plot points from the user, means for calling a generative model based on the information and generating new script elements, means for formatting the generated content into a script format, means for transmitting the formatted script data to the user's terminal, and display means for the user to check and edit the generated script data. This allows users to easily generate high-quality scripts and further edit the generated script in real time through an interface. Furthermore, the use of a cloud server allows for rapid large-scale data processing, providing users with a seamless experience.

[1826] A "theme" refers to the main subject or specific content of a script, the central idea that influences the progression of the story.

[1827] "Character settings" include detailed information about the personalities, backgrounds, roles, etc. of the characters who appear in the script.

[1828] A "plot point" is an element that is an important event or turning point in the progression of a story, and forms the basis for the story's development.

[1829] A "generative model" refers to an algorithm or system that uses machine learning or artificial intelligence to automatically generate new script elements based on user-provided information.

[1830] "Script format" refers to the format in which the generated content is organized according to the format of scene descriptions, dialogue, character introductions, etc.

[1831] A "cloud server" refers to a remote server that can be accessed via the Internet and provides large-scale data processing and storage functions.

[1832] "User's terminal" refers to a computer, smartphone, tablet, etc. used by a user, which is a device for receiving and displaying generated script data.

[1833] "Display means" refers to an interface that allows a user to visually check and edit the generated script data.

[1834] "Data validation" is the step where we check whether the information provided by the user is missing or in an invalid format and take appropriate action.

[1835] "Means for making it editable" refers to the ability for users to modify and fine-tune the generated script as needed.

[1836] This invention is a system that receives information such as the theme, character settings, and plot points of a script provided by a user, and generates new script elements using a generative model based on that information. Specific embodiments are described below.

[1837] Server Operation

[1838] The server plays a central role in this system and performs the following main processes:

[1839] 1. Receiving and validating a request:

[1840] The server receives a request sent by a user using the HTTPS protocol. This request contains information such as the script's theme, character settings, and plot points. The server first checks whether this data is valid. For example, if the theme or character information is missing, it returns an error message.

[1841] 2. Invoke the generative model:

[1842] Given valid data, the server invokes a generative model (e.g., a generative AI model like GPT-4) to generate new script elements, such as dialogue, plot points, and character development, automatically based on the information provided.

[1843] 3. Formatting content:

[1844] The generated script elements are in raw text format, so the server formats them into a script, specifically by organizing the content according to the format of scene descriptions, dialogues, character introductions, etc.

[1845] 4. Sending the response:

[1846] The formatted script data is sent to the user's device. Specifically, the generated results are sent to the user's device via HTTP response or WebSocket.

[1847] Device behavior

[1848] The terminal provides the user interface and is responsible for the following:

[1849] 1. Getting user input:

[1850] The terminal collects input from the user about the script's theme, character settings, plot points, etc. This input is done through a GUI.

[1851] 2. Submit your request:

[1852] The acquired input data is sent to the server. The terminal generates an HTTPS request and sends it to the server, including the necessary parameters.

[1853] 3. Receiving and Displaying Responses:

[1854] It receives the generated results from the server and displays them to the user, providing an interface for the user to edit and modify the displayed data.

[1855] User behavior

[1856] The user performs the following actions:

[1857] 1. Provision of information:

[1858] Users input information about the script's theme, character settings, plot points, etc. For example, if creating a sci-fi script, they input information about the character, such as "engineer, brave, and intelligent."

[1859] 2. Send the generation request:

[1860] The user submits a generation request based on the information they entered. By pressing the "Generate" button, this information is sent to the server.

[1861] 3. Review and edit the results:

[1862] Review the generated script data and edit it as needed, fine-tuning dialogue and plot points to complete the final script.

[1863] Specific examples

[1864] Let's consider a specific example of a movie production company using this system. The theme is "Tokyo of the future," the character is a "police officer of the future with a very keen intuition," and the plot point is a "mysterious disappearance." The following prompt is sent to the generative AI model:

[1865] Example prompt sentence:

[1866] Theme: Future Tokyo

[1867] Character: A police officer from the future with a keen intuition

[1868] Plot Point: Mysterious Disappearance

[1869] Generated script elements please.

[1870] As described above, this invention allows users to easily generate high-quality scripts and then edit the generated scripts in real time through an interface. Furthermore, by using a cloud server, large-scale data processing can be performed quickly, providing users with a seamless experience.

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

[1872] Step 1:

[1873] The user inputs information such as the script's theme, character settings, and plot points through the device's user interface. This information is collected as input data. The input includes specific details such as the theme being "Tokyo of the future," the character setting being "a police officer of the future with a very keen intuition," and the plot point being "a mysterious disappearance."

[1874] Step 2:

[1875] The device sends the collected input data to the server as an HTTPS request, which includes the user's input such as theme, character settings, and plot points.

[1876] Step 3:

[1877] The server validates the data of the received request. This validation process checks whether the data is complete and not invalid. For example, if character information is missing, an error message is generated and returned to the user. The input of this step is the input data from the user, and the output is the validation result.

[1878] Step 4:

[1879] Once valid data is verified, the server invokes a generative AI model (e.g., GPT-4). The generative AI model generates new script elements based on the provided theme, character settings, and plot points. The input is the validated data, and the output is the generated script elements. For example, a script element might be generated such as "A police officer from the future investigates a mysterious disappearance in Tokyo."

[1880] Step 5:

[1881] The generated script elements are returned to the server in raw text format, which the server then formats into a user-friendly script. Specifically, the script is organized according to the format of scene descriptions, dialogues, character introductions, etc. The input of this step is the generated raw text, and the output is formatted script data.

[1882] Step 6:

[1883] The server generates an HTTP response to send the formatted script data to the user's device. This response is used as a display means for the user to check and edit. The input is the formatted script data, and the output is the data sent to the user's device.

[1884] Step 7:

[1885] The terminal displays the script data received from the server. The user reviews this data and makes edits as needed, for example, fine-tuning the dialogue in the generated script or adding plot points. The input is the data received from the server, and the output is the data displayed and edited in the user interface.

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

[1887] This invention is a system that uses a generative model to generate new script elements based on information provided by the user, such as the script's theme, character settings, and plot points, and also combines it with an emotion engine that recognizes the user's emotions and customizes the script content, making it possible to generate more personalized scripts.

[1888] Server Operation

[1889] The server receives a request from the user and performs the following process:

[1890] 1. Receiving and Validating a Request

[1891] The server receives information about the script submitted by the user, such as themes, characterization, plot points, etc. It also checks that the received data is valid and contains all the required information, and returns an error message to the user if any data is missing or invalid.

[1892] 2. Emotion engine activation and analysis

[1893] The server activates an emotion engine and analyzes the user's input data and user interface operation history to recognize the user's emotions, such as the speed at which the text is entered, the content of the input, and the frequency and strength of clicks.

[1894] 3. Invoking the Generative Model

[1895] Based on the recognized emotions, a generative model is invoked, which generates customized dialogue, plot points, character development, etc. based on the user's emotions and the information provided.

[1896] 4. Content Formatting

[1897] The generated script elements are formatted into a script according to the format of scene descriptions, dialogues, character introductions, etc.

[1898] 5. Sending the Response

[1899] The formatted script data is sent to the user's device. The generated script is customized based on the user's emotions, resulting in a more personalized content.

[1900] Device behavior

[1901] The terminal provides a user interface and performs the following processes:

[1902] 1. Getting User Input

[1903] The device gets input from the user about the screenplay's themes, characterization, plot points, etc. For example, it uses forms and select boxes to collect information.

[1904] 2. Collecting Emotional Data

[1905] The device collects data such as the user's typing speed, text content, and click frequency, and passes this information to an emotion engine, which analyzes the user's emotions in real time.

[1906] 3. Submitting a Request

[1907] The acquired input data and emotion data are sent to the server as an HTTP request.

[1908] 4. Receiving and Displaying Responses

[1909] Receives customized script data sent from the server and displays it to the user, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[1910] User Actions

[1911] The user performs the following operations:

[1912] 1. Provision of information

[1913] The user inputs information about the script, such as the theme, character settings, and plot points, into the system. For example, the user inputs a sci-fi theme setting and character details.

[1914] 2. Submitting a Request

[1915] By pressing the "Generate" button, the user sends a generation request to the server based on the input information and the emotion data collected by the device.

[1916] 3. Check and edit the results

[1917] Review the customized script data and make edits and revisions as needed, fine-tuning dialogue, plot points, etc., to complete the final script.

[1918] Specific examples

[1919] As a concrete use case, consider a user writing a science fiction-themed screenplay. The user enters the following information:

[1920] Theme: Sci-Fi

[1921] Character Description: "Taro Tanaka, engineer, brave and intelligent"

[1922] Plot Point: "A space station is severely damaged by a meteorite impact and requires emergency repairs."

[1923] While the user is typing, the emotion engine analyzes their typing speed and click strength to determine if they are impatient. The server then uses a generative model to generate a script that reflects the user's emotions. For example, the tone of the dialogue may be adjusted to create a more tense atmosphere.

[1924] The generated script looks like this:

[1925] Taro Tanaka: "Our mission is to repair the space station. We don't have much time, so hurry!"

[1926] Finally, the server formats the customized script and sends it to the user's device, where the user can review and edit it to complete the final script.

[1927] In this way, by combining emotion engines, more personalized script generation based on the user's emotions can be achieved.

[1928] The processing flow will be explained below.

[1929] Server Processing

[1930] Step 1:

[1931] The server receives requests from users via HTTP requests, WebSockets, etc. The requests contain information such as the script's theme, character settings, and plot points.

[1932] Step 2:

[1933] The server validates the received data, checking whether enough theme and character information has been provided or if any information is missing, and returns an error message to the user if any data is missing or invalid.

[1934] Step 3:

[1935] The server activates an emotion engine and analyzes the user's input data and the user interface operation history to recognize the user's emotion, such as input speed, input content, click frequency and intensity, etc.

[1936] Step 4:

[1937] Based on the emotion data recognized by the emotion engine, a generative model is invoked, which generates new script elements (dialogue, plot points, character development, etc.) based on the user's emotions and the information provided.

[1938] Step 5:

[1939] The generated content is formatted into a script, specifically by organizing the content according to a format such as scene descriptions, dialogue, and character introductions.

[1940] Step 6:

[1941] The formatted script data is sent to the user's device as an HTTP response or WebSocket message.

[1942] Terminal handling

[1943] Step 1:

[1944] The terminal receives input from the user through a GUI, such as the script's theme, character settings, and plot points. The input is collected using forms and select boxes.

[1945] Step 2:

[1946] The device collects data such as the user's typing speed, text content, and click frequency and intensity, and passes this data to the emotion engine. This data is collected in real time as you type.

[1947] Step 3:

[1948] The acquired input data and emotion data are sent to the server in the form of an HTTP request, with appropriate headers and parameters set.

[1949] Step 4:

[1950] The terminal receives the response sent from the server, which includes the generated customized script data.

[1951] Step 5:

[1952] Presents the received script data to the user through a user interface, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[1953] User behavior

[1954] Step 1:

[1955] The user inputs information about the script, such as the theme, character settings, and plot points, into the terminal. For example, the user inputs a sci-fi theme or character details.

[1956] Step 2:

[1957] The user presses the "Generate" button to send a generation request to the server based on the input information and the emotion data collected by the device.

[1958] Step 3:

[1959] The user confirms the customized script data returned from the server, checks the script data displayed on the terminal, and makes edits or corrections as necessary.

[1960] Step 4:

[1961] Users can save or export their edited script, select the file format and destination, and complete the final script.

[1962] This series of steps allows the user, device, and server processes to work together to smoothly advance the script generation process. Customization based on the user's emotions results in a more personalized script.

[1963] Example 2

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

[1965] Conventional script generation systems were able to generate and format script elements based on information received from users, but they were unable to generate personalized scripts that took the user's emotions into account. Because they were unable to create dialogue or set scenes that reflected the user's emotions, it was difficult to create a script that reflected each individual's emotions and intentions during the creative process.

[1966] The specific processing by the specific processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes means for receiving information such as the theme, character settings, and plot points of the script from the user, means for calling a generative model based on the information and generating new script elements, means for formatting the generated content into a script format, means for sending the formatted script data to the user's terminal, means for activating an emotion engine that recognizes the user's emotions and analyzing the user's input data and operation history, and means for customizing the generative model based on the recognized emotions. This makes it possible to generate a script personalized according to the user's emotions.

[1967] A "user" is an entity that uses the system to provide information such as the theme, character settings, and plot points of a script and receives the generated script.

[1968] A "server" is a computer device that receives requests from users and performs a series of processes such as generating, formatting, and transmitting a script.

[1969] "Theme" is information that defines the basic subject matter and genre of the entire script.

[1970] "Character settings" are information that defines the detailed characteristics and roles of the characters that appear in the script.

[1971] A "plot point" is information that indicates an important event or turning point in the progression of a script.

[1972] A "generative model" is an algorithm or program for generating new script elements based on user-provided information.

[1973] "Script elements" are various pieces of content such as dialogue, scene descriptions, and character details that are generated by a generative model.

[1974] An "emotion engine" is a software component that analyzes a user's input data and operation history to recognize emotions.

[1975] "Emotional data" is information such as typing speed, click frequency, and content that is collected to reflect a user's emotions.

[1976] "Formatting" is the process of organizing the generated script elements into a format such as scene descriptions, dialogue, and character introductions.

[1977] An "HTTP request" is a communication format that follows a protocol for sending information from a user's terminal to a server.

[1978] A "prompt sentence" is data in the form of a specific document that is input to a generative model.

[1979] This invention relates to a system that generates new script elements based on information such as themes, character settings, and plot points of a script provided by a user, and also recognizes the user's emotions to personalize the script content. Specific methods for implementing this system are described below.

[1980] Server Operation

[1981] The server uses several software components to process the script generation. First, the server receives the HTTP request sent by the user. This request contains information about the script's theme, character settings, plot points, etc. The server validates the received information to ensure that all required data is present.

[1982] Next, the server launches the emotion engine, which uses a software library called "EmotionalAnalyzer.dll" to analyze the user's input data and operation history (input speed, click frequency, etc.) to recognize the user's emotions. This allows the server to understand the user's emotional state, such as whether they are anxious or relaxed.

[1983] The server then invokes the generative AI model, implemented in the file "ScriptGenerator.ai," which takes emotion data and user-provided data in the form of a prompt. For example, it generates the following prompt:

[1984] "Theme: Sci-Fi, Character: Tanaka Taro, engineer, brave and intelligent, Plot point: A space station is destroyed by a meteorite and requires emergency repairs. Generate tense dialogue that takes into account the user's impatience."

[1985] The generative AI model generates new script elements based on this prompt.

[1986] The generated script elements are formatted into a script using "ScriptFormatter.dll", for example, into scene descriptions, dialogues, character introductions, etc.

[1987] Finally, the formatted script data is sent to the user's device as an HTTP response.

[1988] Device behavior

[1989] The terminal provides a user interface and takes input from the user about the screenplay's theme, character settings, plot points, etc. This input is done through forms and select boxes and stored in a variable, for example "themeInput.value".

[1990] In addition, the device collects data such as the user's typing speed and click frequency in real time and converts it into a format that can be passed to the emotion engine, allowing the server to recognize the user's emotions.

[1991] When the user completes all input and clicks the "Generate" button, the device sends the input data and emotion data to the server as a single HTTP request.

[1992] After receiving the HTTP response from the server, the device displays the received script data to the user in an appropriate format. For example, the dialogue portion is displayed as "quoteElement.innerHTML".

[1993] User Actions

[1994] The user inputs information about the script, such as the theme, character settings, and plot points of the script into the system. For example, they input a sci-fi theme and character details. After completing all the input, the user clicks the "Generate" button to send the request to the server.

[1995] The generated script data is reviewed and, if necessary, the dialogue, scenes, etc. are edited. Finally, the user creates a completed script using a tool such as a text editor.

[1996] In this way, by combining emotion engines, more personalized script generation based on the user's emotions can be achieved.

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

[1998] Step 1:

[1999] Receiving and Validating a Request

[2000] 1. The server receives an HTTP request sent by the user.

[2001] Input: An HTTP request containing information about the screenplay's theme, characterization, plot points, etc.

[2002] Output: Various extracted information.

[2003] 2. The server extracts the received data and checks for missing information or invalid formats.

[2004] Data processing: Checking themes and character settings, and validating that all necessary information is available.

[2005] Behavior: If validation fails, an error message is generated and returned to the user.

[2006] Step 2:

[2007] Emotion engine activation and analysis

[2008] 1. The server starts the emotion engine.

[2009] Input: Extracted user input data and operation history (typing speed, click frequency, etc.).

[2010] Output: The user's emotional state.

[2011] 2. The emotion engine analyzes the input data and recognizes the user's emotions.

[2012] Data calculations: Sentiment analysis using text entry speed, click frequency, and input content.

[2013] How it works: The emotion engine uses the data to determine the user's emotional state, such as whether they are anxious.

[2014] Step 3:

[2015] Invoking the generative model

[2016] 1. The server invokes the generative AI model based on the emotions recognized by the emotion engine.

[2017] Input: User emotional data, script themes, characterization, and plot points.

[2018] Output: The newly generated script element.

[2019] 2. The server converts this data into prompt sentence format and inputs it into the generative model.

[2020] Data processing: Prompt sentence generation.

[2021] How it works: The generative AI model generates new script elements based on the prompt. For example, it generates the following prompt:

[2022] "Theme: Sci-Fi, Character: Tanaka Taro, engineer, brave and intelligent, Plot point: A space station is destroyed by a meteorite and requires emergency repairs. Generate tense dialogue that takes into account the user's impatience."

[2023] Step 4:

[2024] Content Formatting

[2025] 1. The server formats the script elements received from the generative model into a script format.

[2026] Input: Generated script elements.

[2027] Output: Formatted script data.

[2028] 2. The server uses "ScriptFormatter.dll" to organize the generated elements into formats such as scene descriptions, dialogues, character introductions, etc.

[2029] Data processing: Formatting various script elements into a specified format.

[2030] Step 5:

[2031] Sending a response

[2032] 1. The server sends the formatted script data to the user's device as an HTTP response.

[2033] Input: Formatted script data.

[2034] Output: The HTTP response sent to the user's device.

[2035] Step 6:

[2036] Getting User Input

[2037] 1. The device obtains information such as theme, character settings, and plot points through the user interface.

[2038] Input: User-supplied themes, characterizations, and plot points.

[2039] Output: User input data stored on the device.

[2040] 2. The device stores the collected data in a variable, for example, "themeInput.value".

[2041] Behavior: Provides input forms and select boxes.

[2042] Step 7:

[2043] Collecting Emotional Data

[2044] 1. The device collects emotional data such as the user's text input speed, click frequency, and input content.

[2045] Input: User operation data.

[2046] Output: Collected emotion data.

[2047] 2. The device converts this data into a format that can be passed to the emotion engine and stores it in variables.

[2048] Step 8:

[2049] Submitting a Request

[2050] 1. The device sends the collected user input data and emotion data together as an HTTP request to the server.

[2051] Input: Collected user input data and sentiment data.

[2052] Output: The HTTP request sent to the server.

[2053] Step 9:

[2054] Receiving and displaying the response

[2055] 1. The terminal receives the HTTP response returned from the server.

[2056] Input: The HTTP response from the server.

[2057] Output: Received script data.

[2058] 2. The terminal displays the received script data in an appropriate format for the user.

[2059] Behavior: The dialogue is displayed as "quoteElement.innerHTML".

[2060] (Application example 2)

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

[2062] Conventional script generation systems have difficulty identifying user emotions and reflecting them in the script content, which has led to the issue of insufficient script generation personalized for each user. Therefore, there is a need for a method to generate scripts that are more individualized and in line with emotions by generating scripts based on the user's emotions.

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

[2064] In this invention, the server includes means for receiving information such as the theme, character settings, and plot points of the script from the user, means for calling a generative model based on the information and generating new script elements, means for formatting the generated content into a script format, means for sending the formatted script data to the user's terminal, means for collecting the user's input speed and click strength, means for analyzing the collected data to recognize the user's emotions, and means for customizing the generative model according to the emotions. This enables more personalized script generation by analyzing the user's emotions in real time and customizing the script content based on that.

[2065] "Means for receiving information from a user about the screenplay's theme, character settings, plot points, etc." refers to a device or software that provides an interface for a user to input the screenplay's theme, character details, and major plot points.

[2066] The "means for invoking a generative model based on the information and generating new script elements" refers to an algorithm or software module for using artificial intelligence to generate new scenario elements based on the acquired user information.

[2067] "Means for formatting the generated content into a script" refers to a device or software that organizes the generated scenario elements, such as dialogue, scene descriptions, and character introductions, according to a standard scenario format and converts them into an appropriate format.

[2068] "Means for transmitting formatted script data to a user's terminal" refers to a communication device or software for transmitting script data to a device used by a user (e.g., a smartphone or a PC).

[2069] "Means for collecting user typing speed and click intensity" refers to sensors or software for collecting operation data such as a user's typing speed and click frequency and intensity in real time.

[2070] "Means for recognizing user emotions by analyzing collected data" refers to algorithms or software for analyzing collected operation data and determining the user's emotional state (e.g., excitement, tension, relief).

[2071] The "means for customizing generative models according to emotions" is a software module for adjusting the scenario generation algorithm and model output content based on the recognized user emotions.

[2072] This invention is a system that uses a generative model to personalize the theme, character settings, plot points, etc. of a script based on the user's emotions, and provides them through a user interface. Specific embodiments for implementing this invention are described below.

[2073] Server Operation

[2074] The server contains various software modules that perform functions such as:

[2075] 1. Receiving and Validating a Request

[2076] The server receives information about the script submitted by the user, such as themes, characterization, plot points, etc. It also checks that the received data is valid and contains all the required information, and returns an error message to the user if any data is missing or invalid.

[2077] 2. Emotion engine activation and analysis

[2078] The server starts an emotion engine (e.g., SentimentAnalyzer) and analyzes the user's input data and user interface operation history to recognize the user's emotion, such as the speed at which the text is entered, the content of the input, and the frequency and strength of clicks.

[2079] 3. Invoking the Generative Model

[2080] Based on the recognized emotion, a generative AI model (e.g., AIGenerator) is invoked, which generates customized dialogue, plot points, character development, etc. based on the user's emotion and the provided information.

[2081] 4. Content Formatting

[2082] The generated script elements are formatted into a script according to the format of scene descriptions, dialogues, character introductions, etc.

[2083] 5. Sending the Response

[2084] The formatted script data is sent to the user's device. The generated script is customized based on the user's emotions, resulting in a more personalized content.

[2085] Device behavior

[2086] The terminal provides a user interface and performs the following tasks:

[2087] 1. Getting User Input

[2088] The device gets input from the user about the screenplay's themes, characterization, plot points, etc. For example, it uses forms and select boxes to collect information.

[2089] 2. Collecting Emotional Data

[2090] The device collects data such as the user's typing speed, text content, and click frequency, and passes this information to an emotion engine, which analyzes the user's emotions in real time.

[2091] 3. Submitting a Request

[2092] The acquired input data and emotion data are sent to the server as an HTTP request.

[2093] 4. Receiving and Displaying Responses

[2094] Receives customized script data sent from the server and displays it to the user, ensuring that each part of the script (dialogue, plot points, characters, etc.) is displayed in the appropriate format.

[2095] User Actions

[2096] The user does the following:

[2097] 1. Provision of information

[2098] The user inputs information about the script, such as the theme, character settings, and plot points, into the system. For example, the user inputs a sci-fi theme setting and character details.

[2099] 2. Submitting a Request

[2100] By pressing the "Generate" button, the user sends a generation request to the server based on the input information and the emotion data collected by the device.

[2101] 3. Check and edit the results

[2102] Review the customized script data and make edits and revisions as needed, fine-tuning dialogue, plot points, etc., to complete the final script.

[2103] Specific examples

[2104] As a concrete use case, consider a user writing a sci-fi themed screenplay. The user enters the following information:

[2105] Enter the theme of the scenario: SF

[2106] Enter your character's profile: Taro Tanaka, an engineer, brave and intelligent

[2107] Enter the plot point: A space station is destroyed by a meteorite impact and requires emergency repairs.

[2108] When a user enters the above information, the emotion engine detects impatience, and the generative AI model changes the dialogue accordingly to make it more urgent, for example, "Taro Tanaka: 'Our mission is to repair the space station. We don't have time, so hurry!'"

[2109] The system configuration described above makes it possible to generate a personalized script that reflects the user's emotions.

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

[2111] Step 1:

[2112] The user enters information about the script, such as themes, character settings, and plot points.

[2113] Input: User inputs theme "science fiction", character description "Taro Tanaka, engineer, brave and intelligent", and plot point "A space station is destroyed by a meteorite impact, requiring emergency repairs."

[2114] Output: Sends these inputs to the terminal.

[2115] Step 2:

[2116] The device collects additional data, such as the user's typing speed and click strength.

[2117] Input: User input behavior (typing speed, click strength)

[2118] Output: Collected typing speed and click strength data is saved on the device.

[2119] Step 3:

[2120] The device sends the collected information (script information, input speed, and click strength) to the server as an HTTP request.

[2121] Input: Theme, character preference, and plot point information entered by the user, as well as collected typing speed and click intensity data

[2122] Output: HTTP request sent to the server

[2123] Step 4:

[2124] Validates requests received by the server, checking for missing information or invalid formats.

[2125] Input: Screenplay information and related data received by the server

[2126] Output: Error message if there is an error, otherwise proceed to the next step

[2127] Step 5:

[2128] The server activates an emotion engine and analyzes the user's input data and operation data to recognize emotions.

[2129] Input: User interaction data, such as typing speed and click strength

[2130] Output: Analyzed user emotion data (e.g., impatience, excitement)

[2131] Step 6:

[2132] The server invokes a generative AI model to generate new script elements based on the user's emotions and input information.

[2133] Input: User theme, characterization, plot point information, and parsed emotional data

[2134] Output: New script elements based on emotions

[2135] Step 7:

[2136] The server formats the generated script elements into a standard script format.

[2137] Input: Generated script elements

[2138] Output: Formatted scenario data (e.g., dialogue and scene descriptions)

[2139] Step 8:

[2140] The server sends the formatted scenario data to the user's device.

[2141] Input: Formatted scenario data

[2142] Output: Scenario data sent to the user's device

[2143] Step 9:

[2144] The user checks the customized script data received on the device and edits or corrects it as necessary.

[2145] Input: Formatted scenario data

[2146] Output: A script finalized by the user

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[2162] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

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

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

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

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

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

[2168] The following is further disclosed regarding the above embodiment.

[2169] (Claim 1)

[2170] A means to receive information from users about the script's theme, character settings, plot points, etc.

[2171] A means for calling a generative model based on the information and generating new script elements;

[2172] means for formatting the generated content into a screenplay format;

[2173] A means for transmitting the formatted script data to a user's terminal;

[2174] A system including:

[2175] (Claim 2)

[2176] The system of claim 1 , wherein the generative model is capable of generating dialogue, plot points, and character development.

[2177] (Claim 3)

[2178] 10. The system of claim 1, further comprising means for validating the data of said information to check for missing information or invalid format.

[2179] "Example 1"

[2180] (Claim 1)

[2181] A means of receiving data from users such as the scenario theme, character settings, and main points of the story,

[2182] a means for invoking a generation algorithm based on the data to generate new scenario elements;

[2183] A means for formatting the generated content into a scenario format;

[2184] means for transmitting the formatted scenario data to a user's device;

[2185] A system including:

[2186] (Claim 2)

[2187] 10. The system of claim 1, wherein the generation algorithm is capable of generating dialogue, story points, and character development.

[2188] (Claim 3)

[2189] 10. The system of claim 1, further comprising means for validating said data to check for missing data or invalid formats.

[2190] "Application Example 1"

[2191] (Claim 1)

[2192] A means to receive information from users about the script's theme, character settings, plot points, etc.

[2193] A means for calling a generative model based on the information and generating new script elements;

[2194] means for formatting the generated content into a screenplay format;

[2195] A means for transmitting the formatted script data to a user's terminal;

[2196] a display means for allowing a user to check and edit the generated script data;

[2197] A system including:

[2198] (Claim 2)

[2199] 10. The system of claim 1, wherein the generative model is capable of generating dialogue, plot points, and character development, and further wherein the system uses a cloud server.

[2200] (Claim 3)

[2201] 10. The system of claim 1, further comprising means for validating the data of said information and checking for missing information or invalid format, and further comprising means for making the generated script editable through a user interface.

[2202] "Example 2: Combining Emotion Engines"

[2203] (Claim 1)

[2204] A means to receive information from users about the script's theme, character settings, plot points, etc.

[2205] A means for calling a generative model based on the information and generating new script elements;

[2206] means for formatting the generated content into a screenplay format;

[2207] A means for transmitting the formatted script data to a user's terminal;

[2208] means for activating an emotion engine that recognizes the user's emotions and analyzing the user's input data and operation history;

[2209] a means for customizing the generative model based on the recognized emotions; and

[2210] A system including:

[2211] (Claim 2)

[2212] 10. The system of claim 1, wherein the generative model is capable of generating dialogue, plot points, and character development, and further customizing these according to a user's emotions.

[2213] (Claim 3)

[2214] 10. The system of claim 1, further comprising means for validating the information data and checking for missing information or invalid format, and means for inputting emotion data and user-provided data in the form of prompt sentences to the generative AI model.

[2215] "Application example 2 when combining emotion engines"

[2216] (Claim 1)

[2217] A means to receive information from users about the script's theme, character settings, plot points, etc.

[2218] A means for calling a generative model based on the information and generating new script elements;

[2219] means for formatting the generated content into a screenplay format;

[2220] A means for transmitting the formatted script data to a user's terminal;

[2221] A means of collecting user typing speed and click intensity;

[2222] A means of analyzing the collected data to recognize the user's emotions;

[2223] A means to customize generative models according to emotions,

[2224] A system including:

[2225] (Claim 2)

[2226] The system of claim 1 , wherein the generative model is capable of generating dialogue, plot points, and character development.

[2227] (Claim 3)

[2228] 10. The system of claim 1, further comprising means for validating the data of said information to check for missing information or invalid format. [Explanation of symbols]

[2229] 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. A means to receive information from users about the script's theme, character settings, plot points, etc. A means for calling a generative model based on the information and generating new script elements; means for formatting the generated content into a screenplay format; A means for transmitting the formatted script data to a user's terminal; A system including:

2. The system of claim 1 , wherein the generative model is capable of generating dialogue, plot points, and character development.

3. The system of claim 1 further comprising means for validating the data of said information to check for missing information or invalid format.

Images