System

Abstract

A system is provided.SOLUTION: A system, comprising: collecting means; preprocessing means; learning means; analyzing means; response generating means; and displaying means.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] Today, people desire opportunities to interact with anime characters and historical figures in real time. However, current technology makes it difficult to realize natural, interactive dialogue with these characters. In particular, it is difficult to faithfully reproduce a character's unique way of speaking and thought patterns. Furthermore, there is no platform for creating and selling customizable characters, making it difficult to meet the diverse needs of users. There is a need to solve these problems. [Means for solving the problem]

[0005] To solve the above problems, the present invention provides the following means. First, a collection means collects relevant data from sources such as anime dialogue and biographies of historical figures. Next, a preprocessing means cleans and formats the collected data. Next, a learning means trains the character data using a generative AI model, applying the character's unique speaking style and thinking patterns to the model.

[0006] When a user sends a message, the analysis means analyzes the request and identifies the target character. Based on the identified character, the response generation means generates an appropriate response to the user message and transmits it to the terminal. Finally, the display means displays the generated response to the user via the user interface.

[0007] This allows users to enjoy natural interactions with their favorite characters and historical figures, and by providing a platform where users can create and sell their own original characters, the company can meet a wide range of needs.

[0008] "Collection methods" are the means by which relevant data, such as anime lines or biographies of historical figures, is obtained from websites or APIs.

[0009] "Preprocessing means" refers to means for cleaning and formatting the data collected by the collection means.

[0010] A "learning method" is a means of inputting character data into a generative AI model and applying the character's unique speaking style and thinking patterns to the model.

[0011] The "analysis means" is a means for receiving a user request, analyzing the content of the request, and identifying the target character.

[0012] The "response generation means" is a means for generating an appropriate response to a user message using the AI ​​model of the character identified by the analysis means.

[0013] The "display means" is a means for displaying the generated response to the user via a user interface.

[0014] A "user interface" is an interface through which a user can input messages and interact with characters.

[0015] A "generative AI model" is a model that uses artificial intelligence technology to generate natural dialogue responses from text data.

[0016] "Cleaning" is the process of removing unnecessary information and noise from collected data and shaping it into usable data.

[0017] "Character data" refers to data such as lines and speech patterns related to a specific character. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0026] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0039] The system of the present invention allows users to naturally interact with anime characters and historical figures, and is realized by the following means: First, the processing performed by the server will be described.

[0040] Processing performed by the server

[0041] Obtaining character data

[0042] The server collects relevant data, such as lines from anime or biographies of historical figures, from websites and APIs. The server then stores the collected data. The server also manages the collected data using a database. For example, the server obtains line data related to a specific character and stores it in the database.

[0043] Data Preprocessing

[0044] The server cleans the collected data and removes unnecessary data and noise. To do this, the server performs data formatting. Specifically, it tokenizes and normalizes the text data to make it easier to analyze. For example, it removes noise and inappropriate expressions from the acquired dialogue data.

[0045] Training generative AI models

[0046] The server uses the preprocessed data to train a generative AI model, using artificial intelligence technology to learn the character's speech patterns and thought patterns. For example, the model learns what words a particular character uses in what situations. This learning process makes it possible to faithfully reproduce the character's characteristics.

[0047] Parsing user requests

[0048] The server receives the request message sent by the user and analyzes its contents. This analysis determines which character the request is directed to and the intent of the request. For example, if a user sends a message saying "How was your day?", the message is analyzed as a question for a specific character.

[0049] Generate and send a response

[0050] The server uses an appropriate character generation AI model based on the analysis results to generate a response to the user's message. This response realizes natural dialogue based on the character's characteristics. The generated response is sent from the server to the user's device. For example, a model of Sakata Gintoki might respond to a user's question by saying, "I spent today watching movies."

[0051] Processing performed by the device

[0052] Providing a user interface

[0053] The terminal displays a chat interface for the user to interact with the character. In this interface, the user can input and send messages. For example, a chat window is displayed on a smartphone application.

[0054] Accepting and sending user input

[0055] The terminal prepares to send the message entered by the user to the server. When the user enters a message and presses the send button, the message is sent from the terminal to the server. For example, the user enters "What is your favorite food?" and presses the send button.

[0056] Response from the server

[0057] The device displays the response message received from the server on the chat interface. The received message is displayed in a form visible to the user, and a dialogue takes place. For example, a response such as "My favorite food is dumplings" is displayed.

[0058] User actions

[0059] Character Selection

[0060] The user selects the character they want to chat with from a list of characters provided on the platform. For example, the user selects Sakata Gintoki and starts chatting.

[0061] Starting and continuing a chat conversation

[0062] The user enters a message and presses the send button to begin a conversation with the selected character. Once the conversation begins, the user can continue to ask questions and receive responses. For example, the user can enter "How was your day?" and receive a response from the character saying "I spent today watching movies."

[0063] The present invention, as described above, allows users to enjoy natural conversations with their favorite characters and historical figures, and also provides a platform where users can create and sell their own original characters, thereby meeting a variety of needs.

[0064] The processing flow will be explained below.

[0065] Step 1:

[0066] Data collection (server)

[0067] The server collects relevant data, such as anime lines or biographies of historical figures, from websites and APIs, and stores the collected data in a database.

[0068] Step 2:

[0069] Data preprocessing (server)

[0070] The server cleans and formats the collected data, removing unnecessary data and noise, and tokenizing and normalizing the text data.

[0071] Step 3:

[0072] Creating a dataset (server)

[0073] The server creates a training dataset based on the preprocessed data, extracting data related to specific characters and formatting it for training.

[0074] Step 4:

[0075] Training generative AI models (server)

[0076] The server uses the created dataset to train a generative AI model, which in turn learns the character's unique speech patterns and thought patterns.

[0077] Step 5:

[0078] Receiving user requests (server)

[0079] The server receives messages from users, for example, messages that users type into a chat window are sent to the server.

[0080] Step 6:

[0081] Request analysis (server)

[0082] The server analyzes the received message and identifies the message content and target character using natural language processing technology.

[0083] Step 7:

[0084] Response generation (server)

[0085] The server uses the AI ​​model of the identified character to generate a response to the user's message, where the generated response is based on the character's characteristics.

[0086] Step 8:

[0087] Response sending (server)

[0088] The server then sends the generated response to the user's terminal in a format that will be displayed in the user's chat window.

[0089] Step 9:

[0090] User interface display (terminal)

[0091] The device displays a chat interface for the user, which includes a message entry field and a send button.

[0092] Step 10:

[0093] Accepting user input (terminal)

[0094] When the user inputs a message and presses the send button, the terminal transmits the input message to the server.

[0095] Step 11:

[0096] Display of response message (terminal)

[0097] The terminal displays the response message received from the server on the chat interface, and the user can see the character's response through the terminal.

[0098] Step 12:

[0099] Character Selection (User)

[0100] Users select the character they want to chat with from a list on the platform, and a conversation begins based on the selected character.

[0101] Step 13:

[0102] Continue chat (user)

[0103] The user can continue to interact with the character by typing messages and periodically sending new messages, receiving replies from the character, and continuing the conversation.

[0104] Example 1

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

[0106] Currently, many users desire to converse naturally with their favorite anime characters or historical figures, but existing systems have difficulty fully reproducing the natural conversational abilities of characters. Furthermore, building a dialogue system using a generative AI model requires the collection and preprocessing of a huge amount of data, and efficient methods for doing this are needed. Furthermore, the ease of use of the user interface and the generation of responses in real time are also important issues.

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

[0108] In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, and a display means. This allows natural language data to be collected from websites and APIs, and preprocessed through cleaning, tokenization, and normalization. The preprocessed data can then be used to train a generative AI model, which can generate and send appropriate responses based on user requests, enabling natural interactions between the user and the character.

[0109] "Collection Methods" are the methods used to collect natural language data from websites and APIs.

[0110] The "preprocessing means" is a means for tokenizing, normalizing, and cleaning the collected data.

[0111] A "learning means" is a means for training a generative AI model using preprocessed data.

[0112] The "analysis means" is a means for receiving a request message from a user and analyzing the content related to the character.

[0113] "Response generation means" refers to a means for generating an appropriate response using a generative AI model based on the analysis results.

[0114] The "display means" is a means for transmitting the generated response to the user terminal and displaying it.

[0115] The system of the present invention allows users to naturally interact with anime characters and historical figures, and is realized by the following means: Specifically, the entire system functions by the server, terminal, and user fulfilling their respective roles.

[0116] Server processing

[0117] Obtaining character data

[0118] The server uses the Python requests library to collect natural language data from websites and APIs. For example, it can retrieve lines from anime characters or biographical data from historical documents, and store the data in a database such as MongoDB. This data collection creates a language database for each character.

[0119] Data Preprocessing

[0120] The server preprocesses the collected data using data processing libraries such as Pandas and Numpy. This preprocessing includes cleaning, tokenizing, and normalizing the data. For example, it removes unnecessary HTML tags and special characters from the acquired text data to make it easier to analyze.

[0121] Training generative AI models

[0122] The server uses the preprocessed data to train a generative AI model. This process uses generative AI models such as GPT-3 and BERT and deep learning frameworks such as TensorFlow and PyTorch. For example, the server can learn the speech patterns of anime characters or statements by historical figures and use them to generate responses.

[0123] Parsing user requests

[0124] The server receives the request message sent by the user and analyzes its content using natural language processing technology. For example, when a user sends a message such as "How was your day?", the server analyzes the message and processes it as a question related to a specific character.

[0125] Generate and send a response

[0126] The server uses an appropriate generative AI model based on the analysis results to generate a response to the user's message. The generated response is then sent from the server to the user's device. For example, a model of an anime character might generate a response such as "I spent today watching a movie" and send it.

[0127] Processing by the terminal

[0128] Providing a user interface

[0129] The terminal displays a chat interface that allows the user to interact with the character, for example, by displaying a chat window on a smartphone application, allowing the user to enter messages.

[0130] Accepting and sending user input

[0131] The terminal sends the message entered by the user to the server. For example, if the user enters "What is your favorite food?" and presses the send button, the message is sent from the terminal to the server.

[0132] Response from the server

[0133] The device displays the response message received from the server in the chat interface, for example, the message "My favorite food is dumplings."

[0134] User operation

[0135] Character Selection

[0136] The user selects from a list of characters with whom they want to chat, for example, the user selects a particular character and types a message to begin chatting.

[0137] Starting and continuing a chat conversation

[0138] The user enters a message and presses the send button to begin a conversation with the selected character. Once the conversation begins, the user can continue to ask questions and receive responses. For example, the user can enter "How was your day?" and receive a response from the character saying "I spent today watching movies."

[0139] Examples of prompt statements

[0140] For example, a dialogue with a character can be realized using the following prompt sentence:

[0141] The user types, "What is your favorite food?"

[0142] The server consults the character's dialogue database and generates an appropriate response.

[0143] Generated response: "My favorite food is dango."

[0144] This system allows users to enjoy natural conversations with anime characters and historical figures, and uses natural language processing technology with generative AI models to enable real-time conversations.

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

[0146] Step 1: Obtaining Character Data

[0147] The server collects natural language data from websites and APIs. It uses Python's requests library to send HTTP requests to API endpoints and retrieves JSON data as a response. For example, it retrieves lines from anime characters or biographies of historical figures from the API and stores them in a local database (e.g., MongoDB). Inputs include the API URL and query parameters, and the retrieved natural language data is stored in the database as output.

[0148] Step 2: Preprocessing the data

[0149] The server cleans, tokenizes, and normalizes the collected natural language data. For data preprocessing, it uses data processing libraries such as Pandas and Numpy. Specifically, it removes HTML tags and special characters from the collected text data to obtain formatted text data. For example, Hello " is converted into a clean form like "Hello." The input is natural language data in JSON format, and the output is cleaned, tokenized, and normalized text data.

[0150] Step 3: Training the generative AI model

[0151] The server uses the preprocessed data to train a generative AI model. This model training uses a deep learning framework such as TensorFlow or PyTorch. As a specific example, to learn the speech patterns of anime characters, the preprocessed data is input to the model as a dataset and training is performed through multiple epochs. The inputs are the cleaned text data and the model's hyperparameters, and the output is a trained generative AI model.

[0152] Step 4: Parsing the user request

[0153] The server analyzes the request message received from the user. Using natural language processing technology (e.g., spaCy or NLTK), it tokenizes the user's input message and identifies its intent and the target character. For example, if a user sends a message saying, "How was your day?", the intent of the question is analyzed and it is determined that the question is related to Sakata Gintoki. The input is the user's message, and the output is the analyzed intent and information about the target character.

[0154] Step 5: Generate and send a response

[0155] The server uses an appropriate generative AI model based on the analysis results to generate a response to the user message. The generated response is sent from the server to the user's device. For example, Sakata Gintoki's generative AI model generates a response such as "I spent today watching a movie" and sends it to the user's device. The inputs are the analysis results and the generative AI model, and the output is the generated response message sent to the user's device.

[0156] Step 6: Providing a User Interface

[0157] The terminal displays a chat interface that allows the user to interact with the character. This interface allows the user to input and send messages. For example, a chat window may be displayed on a smartphone application, allowing the user to input messages in an input field. The input includes interface design information for the application, and the output is the displayed chat interface provided to the user.

[0158] Step 7: Accepting and Sending User Input

[0159] The terminal sends messages entered by the user to the server. When the user enters a message and presses the send button, the message is sent from the terminal to the server and passed to the server for processing. For example, when the user enters "What is your favorite food?" and presses the send button, the message is sent from the terminal to the server. As input we have the user's message and as output we have the sent message sent to the server.

[0160] Step 8: View the response from the server

[0161] The terminal displays the response message received from the server in the chat interface. For example, the terminal receives a response message from the server saying "My favorite food is dumplings" and displays it to the user. The response message received from the server is the input, and the response displayed in the chat interface is the output provided to the user.

[0162] This series of processes allows users to enjoy natural conversations with anime characters and historical figures.

[0163] (Application example 1)

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

[0165] Today's users demand richer, more interactive experiences than simple text or voice chat. However, existing systems struggle to deliver real-time responses that match the character's personality and voice. They also lack the history management capabilities to enable users to review past conversations and enjoy long-term interactions with the character. This calls for new ways to improve user satisfaction and the quality of entertainment.

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

[0167] In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, a display means, a means for playing back a response message on a terminal using a speech synthesis engine, a communication means for processing user messages in real time, and a history management means for managing dialogue with characters. This allows users to enjoy natural dialogue with unique characters in real time and also allows them to look back on past dialogue history.

[0168] "Collection means" is the function that collects necessary data from websites and APIs and stores it in a database.

[0169] "Preprocessing means" is a function that cleans collected data, tokenizes and normalizes it, and prepares text data in an analyzable format.

[0170] "Learning tools" are functions that use pre-processed data to train a generative AI model to learn the character's speech patterns and thought patterns.

[0171] "Analysis means" is a function that analyzes messages sent by users and understands the intent of the request and the target character.

[0172] The "response generation means" is a function that uses a generative AI model based on the analysis results to generate an appropriate response to a user message.

[0173] The "display means" is a function that displays the generated response message on the user device.

[0174] A "voice synthesis engine" is a technology that converts text data into speech in the voice of a specified character and plays it back in a natural voice.

[0175] The "communication means" is a function that sends messages from users to a server and transmits responses generated by the server to user terminals in real time.

[0176] The "history management means" is a function that stores the history of interactions with characters and allows the user to refer to that history at any time.

[0177] This invention is a system that allows users to enjoy natural conversations with anime characters and historical figures. An example of this system is shown below.

[0178] System Configuration

[0179] This system consists of a server and a user terminal. The server includes a collection means, a preprocessing means, a learning means, a analyzing means, a response generation means, and a speech synthesis engine. The user terminal includes a display means, a user interface, a communication means, and a history management means.

[0180] Server Processing

[0181] 1. Collection Method:

[0182] The server collects data such as anime dialogue and biographies of historical figures from websites and APIs, and stores it in a database, where dialogue data is organized by character.

[0183] 2. Pretreatment methods:

[0184] The server cleans the collected data, tokenizing and normalizing it, which removes noise from the text data and makes it parseable.

[0185] 3. Learning tools:

[0186] The preprocessed data is used to train a generative AI model, which then learns the character's speaking style and thought patterns, enabling it to generate natural-looking dialogue.

[0187] 4. Analysis method:

[0188] The server analyzes messages sent by users and understands their intent. For example, a message like "How was your day?" is recognized as a question for a specific character.

[0189] 5. Response Generation Methods:

[0190] Based on the analysis results, an appropriate character generation AI model is used to generate a response to the user's message, for example, "I spent today watching movies."

[0191] 6. Speech synthesis engine:

[0192] The generated response is synthesized into a voice using the specified character's voice and played back as a natural voice.

[0193] User terminal processing

[0194] 1. Display and User Interface:

[0195] The user terminal provides a chat interface for interaction, where users can type and send messages.

[0196] 2. Means of communication:

[0197] A message entered by the user is transmitted to the server via the communication means, and a response generated by the server is transmitted to the user terminal via the communication means again.

[0198] 3. History Management Methods:

[0199] The device stores the history of interactions with the character, allowing the user to refer to past interactions at any time.

[0200] Hardware and software used

[0201] Smartphones, smart glasses, head-mounted displays: used as user devices.

[0202] Text analysis libraries (e.g. spaCy): Used to preprocess data.

[0203] Generative AI model (e.g. GPT): Used as a generative AI model.

[0204] A speech synthesis engine (e.g., Amazon Polly): Used for speech synthesis.

[0205] Specific examples

[0206] When a user interacts with a character named Sakata Gintoki, the user inputs and sends the message "How was your day?". An example of a prompt sentence is "When you ask Sakata Gintoki, "How was your day?", generate a response from his character model."

[0207] This allows the system to generate a response such as "I spent today watching movies," which can be displayed on the user's device and played back as audio.

[0208] Thus, the system of the present invention allows users to enjoy natural and interactive dialogue with anime characters and historical figures.

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

[0210] Step 1:

[0211] Collecting character data

[0212] The server collects data such as anime dialogue and biographies of historical figures from websites and APIs, and organizes this data by character and stores it in a database.

[0213] Input: Text data obtained from a website or API

[0214] Output: Raw data stored in a database

[0215] Specific operation: The server accesses a specific URL and retrieves the lines and information of each character. The retrieved data is then stored directly in the database.

[0216] Step 2:

[0217] Data Preprocessing

[0218] The server cleans the collected data, tokenizing and normalizing it, which removes noise from the text data and puts it into a format that can be analyzed.

[0219] Input: Raw data stored in a database

[0220] Output: Preprocessed, clean text data

[0221] What it does: The server uses a text analysis library (e.g. spaCy) to tokenize the text and remove unnecessary noise and profanity.

[0222] Step 3:

[0223] Training generative AI models

[0224] The server uses the preprocessed data to train a generative AI model (e.g., GPT), which learns the character's speaking style and thought patterns, enabling it to generate natural dialogue.

[0225] Input: Preprocessed text data

[0226] Output: A trained generative AI model

[0227] Specific operation: The server uses an AI learning framework (e.g., TensorFlow) to input the preprocessed data into an AI model to learn the character's characteristics.

[0228] Step 4:

[0229] Parsing user requests

[0230] The server analyzes messages sent by users and understands their intent. For example, a message like "How was your day?" is recognized as a question to a specific character.

[0231] Input: Message from user

[0232] Output: Analyzed intent and target character

[0233] Specific operation: The server uses natural language processing (NLP) algorithms to analyze the user message and identify the message's intent and target characters.

[0234] Step 5:

[0235] Generating a response

[0236] The server uses the analysis results to generate a response to the user's message using an appropriate character generation AI model, for example, "I spent today watching movies."

[0237] Input: Analysis results and generated AI model

[0238] Output: The generated text response

[0239] Specific operation: The server inputs a prompt sentence into the generative AI model and generates a corresponding response for each character.

[0240] Step 6:

[0241] Speech synthesis

[0242] The server synthesizes the generated response in the voice of the specified character and plays it back as a natural voice.

[0243] Input: Generated text response

[0244] Output: A synthesized response

[0245] What happens: The server uses a speech synthesis engine (e.g., Amazon Polly) to convert the generated text response into audio data.

[0246] Step 7:

[0247] Response display on user terminal

[0248] The user terminal displays the response received from the server on the user interface.

[0249] Input: Text and audio data from the server

[0250] Output: Display and audio playback in the chat interface

[0251] Specific behavior: Display the response text in the chat interface and play the synthesized voice from the audio speaker.

[0252] Step 8:

[0253] History and Reference

[0254] The user terminal stores a history of interactions with the character, allowing the user to refer to past interactions at any time.

[0255] Input: Response and user message data

[0256] Output: Saved interaction history

[0257] Specific behavior: Each time a conversation is completed, the message and response are saved in a database, and past conversations are displayed when the user opens the history screen.

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

[0259] The system of the present invention not only allows users to naturally interact with anime characters and historical figures, but also recognizes the user's emotions and generates responses based on those emotions. The following describes in detail each means and operation of the system.

[0260] Processing performed by the server

[0261] Obtaining character data

[0262] The server collects relevant data, such as lines from anime or biographies of historical figures, from websites and APIs. The collected data is stored in a database. For example, it retrieves the lines related to a specific character and stores them in the database.

[0263] Data Preprocessing

[0264] The server cleans and formats the collected data. Specifically, it removes unnecessary data and noise, and tokenizes and normalizes the text data. This makes the data easier to analyze. For example, it removes noise from dialogue data and formats it in a format suitable for analysis.

[0265] Training generative AI models

[0266] The server uses the preprocessed data to train a generative AI model, which then learns the character's unique speech patterns and thought patterns. For example, the AI ​​model learns what words a particular character uses in what situations, and then reproduces the character's characteristics.

[0267] Parsing user requests

[0268] The server receives the request message sent by the user and analyzes its contents. This analysis determines which character the request is directed to and the intent of the request. For example, if a user sends a message saying "How was your day?", the message is analyzed as a question for a specific character.

[0269] Emotion analysis

[0270] The server analyzes the emotion of a user message using an emotion engine. The emotion engine identifies emotions from the text content and provides the information to the analysis means. For example, if a user sends a message saying "I'm happy!", the emotion engine identifies "joy" as the emotion.

[0271] Generate and send a response

[0272] Based on the results of the emotion analysis, the server uses a generative AI model of the target character to generate an appropriate response to the user's message. The generated response is based on the character's characteristics and the user's emotions. The response is sent from the server to the user's device. For example, if a user sends a message saying, "I feel sad," the model of Sakata Gintoki will respond with, "I see, that must have been tough. But I'm sure something good will happen tomorrow!"

[0273] Processing performed by the device

[0274] Providing a user interface

[0275] The device displays a chat interface that allows the user to interact with the character. This interface includes a message input field and a send button. For example, a chat window is displayed on a smartphone application.

[0276] Accepting and sending user input

[0277] When a user inputs a message and presses the send button, the terminal sends the input message to the server. For example, a user inputs "How was your day today?" and presses the send button.

[0278] Response from the server

[0279] The device displays the response message received from the server in the chat interface. The response message is displayed in a visible form to the user. For example, a response such as "Today was busy, but it was fun!" may be displayed.

[0280] User actions

[0281] Character Selection

[0282] Users can select a character they want to chat with from a list on the platform, and a conversation will begin based on the selected character. For example, a user can select Sakata Gintoki from the list and start chatting.

[0283] Continue chatting

[0284] The user can continue the conversation by typing messages and periodically sending new messages to the character. The character will then respond and the conversation can continue. For example, the user can type "How are you doing lately?", and the character will respond with "I'm fine, how about you?"

[0285] The present invention, as described above, allows users to enjoy natural conversations with their favorite characters and historical figures. Furthermore, the quality of the conversation can be improved by recognizing the user's emotions and generating responses based on those emotions. Furthermore, the present invention can meet a variety of needs by providing a platform where users can create and sell their own unique characters.

[0286] The processing flow will be explained below.

[0287] Step 1:

[0288] Data collection (server)

[0289] The server collects relevant data, such as lines from anime or biographies of historical figures, from websites and APIs. The collected data is stored in a database. For example, it retrieves the lines related to a specific character and stores them in the database.

[0290] Step 2:

[0291] Data preprocessing (server)

[0292] The server cleans and formats the collected data. Specifically, it removes unnecessary data and noise, and tokenizes and normalizes the text data. This makes the data easier to analyze. For example, it removes noise from dialogue data and formats it in a format suitable for analysis.

[0293] Step 3:

[0294] Creating a dataset (server)

[0295] The server creates a training dataset based on the preprocessed data. It extracts data related to specific characters and formats it for training purposes. For example, it extracts only the lines of Sakata Gintoki and formats them as a training dataset.

[0296] Step 4:

[0297] Training generative AI models (server)

[0298] The server uses the created dataset to train a generative AI model. During this process, the AI ​​model learns the character's unique speaking and thinking patterns. For example, the AI ​​model learns what words a particular character uses in what situations, and reproduces the character's characteristics.

[0299] Step 5:

[0300] Receiving user requests (server)

[0301] The server receives messages from users, for example, messages that users type into a chat window are sent to the server.

[0302] Step 6:

[0303] Request analysis (server)

[0304] The server analyzes the received message and identifies the message content and the target character. Natural language processing technology is used for the analysis. For example, if a user sends a message saying, "How was your day?", the message is analyzed as a question for a specific character.

[0305] Step 7:

[0306] Sentiment analysis (server)

[0307] The server analyzes the emotion of a user message using an emotion engine. The emotion engine identifies emotions from the text content and provides the information to the analysis means. For example, if a user sends a message saying "I'm happy!", the emotion engine identifies "joy" as the emotion.

[0308] Step 8:

[0309] Response generation (server)

[0310] Based on the results of the emotion analysis, the server uses a generative AI model of the target character to generate an appropriate response to the user's message. The generated response is based on the character's characteristics and the user's emotions. For example, if a user sends a message saying, "I feel sad," the model of Sakata Gintoki will respond with, "I see, that must have been tough. But I'm sure something good will happen tomorrow!"

[0311] Step 9:

[0312] Response sending (server)

[0313] The server then sends the generated response to the user's device. The response message is sent in the format that will be displayed in the user's chat window. For example, in response to the question "How was your day?", "I had a great time today!" is sent to the device.

[0314] Step 10:

[0315] User interface display (terminal)

[0316] The device displays a chat interface that allows the user to interact with the character. This interface includes a message input field and a send button. For example, a chat window is displayed on a smartphone application.

[0317] Step 11:

[0318] Accepting user input (terminal)

[0319] When a user inputs a message and presses the send button, the terminal sends the input message to the server. For example, a user inputs "How was your day today?" and presses the send button.

[0320] Step 12:

[0321] Response display from server (terminal)

[0322] The device displays the response message received from the server in the chat interface. The response message is displayed in a visible form to the user. For example, "How was your day?" is displayed in response to "Today was busy, but fun!"

[0323] Step 13:

[0324] Character Selection (User)

[0325] Users can select a character they want to chat with from a list on the platform, and a conversation will begin based on the selected character. For example, a user can select Sakata Gintoki from the list and start chatting.

[0326] Step 14:

[0327] Continue chat (user)

[0328] The user can continue the conversation by typing messages and periodically sending new messages to the character. The character will then respond and the conversation can continue. For example, the user can type "How are you doing lately?", and the character will respond with "I'm fine, how about you?"

[0329] The present invention, as described above, allows users to enjoy natural conversations with their favorite characters and historical figures. Furthermore, the quality of the conversation can be improved by recognizing the user's emotions and generating responses based on those emotions. Furthermore, the present invention can meet a variety of needs by providing a platform where users can create and sell their own unique characters.

[0330] Example 2

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

[0332] Existing chat systems have made it difficult for users to interact naturally with characters or historical figures. They also lacked the technology to properly recognize users' emotions and generate responses based on them. This limited the user experience and reduced the quality of the interaction.

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

[0334] In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a sentiment analysis means, a response generation means, and a display means, which allows a user to have natural conversations with characters or historical figures and receive responses based on the user's sentiments.

[0335] A "collection method" is a part of a system that automatically retrieves information from websites and data sources and stores it in a database.

[0336] "Preprocessing means" is the part of the system that cleans collected data and processes it through processes such as tokenization and normalization, making it suitable for analysis and model training.

[0337] The "learning means" is the part of the system that uses pre-processed data to train the generative AI model to acquire a character's unique speech patterns and thought patterns.

[0338] The "analysis means" is a part of the system that receives a request sent by a user, analyzes the content of the request, and understands the intent of the message and the person being interacted with.

[0339] The "emotion analysis means" is the part of the system that identifies emotions from users' messages and provides that information to the analysis means.

[0340] A "response generation means" is a part of the system that generates an appropriate response to a user message using a generative AI model based on the results of sentiment analysis.

[0341] The "display means" is a part of the system that provides an interface for interaction between the user and the character, and displays message input and responses from the server.

[0342] The system of the present invention not only allows users to naturally interact with anime characters and historical figures, but also recognizes the user's emotions and generates responses. The following hardware and software are used to implement this system.

[0343] 1. Server

[0344] The server includes a collection means for collecting information from websites and data sources, a pre-processing means for performing pre-processing such as cleaning and tokenizing the data, a learning means for training the generative AI model, an analysis means for analyzing user requests, a sentiment analysis means for performing sentiment analysis, and a response generation means for generating responses to the user.

[0345] Collection Method

[0346] The server uses a Python scraping tool (e.g., BeautifulSoup) to collect data about characters and historical figures from websites, which is then stored in an SQL database.

[0347] Pretreatment means

[0348] The server uses the Python NLTK library to perform data cleaning and text tokenization / normalization. The collected data is then tokenized and normalized to remove unnecessary noise and prepare it in a format suitable for analysis.

[0349] Learning tools

[0350] The server trains a generative AI model (e.g., GPT-3) using TensorFlow or PyTorch, which learns the character's unique speech patterns and language usage, acquiring the character's characteristics.

[0351] Analysis means

[0352] The server uses Natural Language Processing (NLP) technology to analyze the request message from the user. Specifically, it analyzes the message received as an HTTP request and identifies its intent and target.

[0353] Emotion analysis means

[0354] The server analyzes the emotion of the user message using an emotion recognition API (for example, Microsoft Azure's Text Analytics API). The result of the emotion analysis is identified as an emotion such as "joy" or "sadness."

[0355] Response Generation Method

[0356] The server uses a generative AI model to generate an appropriate response based on the results of emotion analysis. For example, if a user enters "I was sad today," the server generates a response such as "That was tough, but I'm sure good things will happen tomorrow!"

[0357] 2. Terminal

[0358] The terminal provides an interface for users to interact with characters, and has the following main functions:

[0359] Providing a user interface

[0360] The device uses a mobile application framework (e.g., React Native) to display a chat interface, which includes a message input field and a send button.

[0361] Accepting and sending user input

[0362] When a user enters a message and presses the send button, the device automatically sends the message to the server as an HTTP POST request, triggered by an event listener on the device.

[0363] Response from the server

[0364] The terminal displays the response message received from the server in the chat window. The response message is displayed in real time so that the user can check it immediately.

[0365] 3. Users

[0366] The user interacts with the character via the terminal.

[0367] Character Selection

[0368] Users select the character they want to interact with from a list on the platform, and then the interaction begins.

[0369] Enter and send a message

[0370] The user enters a message to continue the conversation and presses the send button, for example, "How was your day today?" This input is immediately sent to the server.

[0371] Prompt Sentence Examples

[0372] Prompt: "I felt sad."

[0373] Character: fictional character

[0374] Sample response: "I see, that was tough. But I'm sure tomorrow will be better!"

[0375] Based on these steps, users can enjoy natural and emotional interactions with characters and historical figures.

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

[0377] Step 1: Obtaining Character Data

[0378] The server collects data related to characters and historical figures from websites and APIs. A Python scraping tool (e.g., BeautifulSoup) is used as the collection method. A specific URL or API endpoint is specified as input, and dialogue or text data is obtained as output. The collected data is then stored in an SQL database.

[0379] Specifically, the server accesses the specified URL, analyzes the HTML structure, and extracts the required text data. When retrieving data from the API, it requests the data using the API key and parameters, and receives the response.

[0380] Step 2: Preprocessing the data

[0381] The server cleans and preprocesses the collected data. It uses the Python NLTK library as a preprocessing method, taking the collected text data as input and generating tokenized and normalized data as output.

[0382] Specifically, the server removes unnecessary noise and typos from the collected text data, tokenizes the text to break it down into words and phrases, and normalizes the word forms to make them uniform.

[0383] Step 3: Training the generative AI model

[0384] The server uses the preprocessed data to train a generative AI model, using TensorFlow or PyTorch as the learning medium. It provides the preprocessed dataset as input and obtains a trained generative AI model as output.

[0385] Specifically, the server uses the dataset to adjust the model's parameters and train it to learn the character's unique vocabulary and speaking style. This process is repeated, improving the model's accuracy based on a large amount of data.

[0386] Step 4: Receiving and parsing user requests

[0387] The device receives messages from users and sends them to the server. NLP technology is used as the analysis method. The request message from the user is received as input, and the intention of the message and the target character are identified as output.

[0388] Specifically, the device receives the user's message from the message input field and sends it to the server as an HTTP POST request. The server then analyzes the received message and understands its content.

[0389] Step 5: Sentiment Analysis

[0390] The server uses an emotion recognition API to analyze the emotion of the user message. As a means of emotion analysis, it uses Microsoft Azure's Text Analytics API. It receives the user message as input and generates identified emotion information as output.

[0391] Specifically, the server sends the user's text message to an emotion recognition API and identifies the emotion based on the response from the API. For example, the message "I'm happy!" is identified as "joy."

[0392] Step 6: Generate and send a response

[0393] The server uses the generative AI model to generate an appropriate response to the user message. As a response generator, it provides inputs including the results of preprocessing and sentiment analysis, and generates a response message as an output.

[0394] Specifically, the server operates a generative AI model based on the results of emotion analysis to generate an appropriate response. For example, if a user inputs "I was sad today," the system generates a response such as "That was tough, but I'm sure good things will happen tomorrow!" The generated response is then sent from the server to the user's device.

[0395] Step 7: User Interface Display

[0396] The device provides a chat interface for interaction between the user and the character. It uses a mobile application framework such as React Native as the display method. It receives response messages from the server as input and displays them in the chat window as output.

[0397] Specifically, the device receives messages from the server in real time and reflects them on the user interface, allowing the user to instantly see the character's response.

[0398] Step 8: Accepting and Sending User Input

[0399] When the user types a message and presses the send button, the device sends the message to the server. It takes a text message from the user as input and sends it to the server as output.

[0400] Specifically, the user enters the content of the conversation in the message input field and presses the send button. This input information is sent to the server as an HTTP POST request by the terminal.

[0401] Step 9: View the response from the server

[0402] The terminal displays the response message received from the server in the chat interface. It receives the response message from the server as input and displays it in a form that is visible to the user as output.

[0403] Specifically, the terminal reflects the response from the server in the chat window in real time, allowing the user to check it immediately.

[0404] (Application example 2)

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

[0406] Conventional virtual stores have the problem that users cannot receive appropriate support through dialogue when selecting products, which prevents them from fully increasing their purchasing motivation and satisfaction. In addition, they lack a mechanism to provide a more personalized purchasing experience by recognizing users' emotions and generating responses based on them.

[0407] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, an emotion analysis means, a virtual store means for supporting the user's purchasing behavior through dialogue, and a display means. This enables the user to receive a personalized response based on emotion when selecting a product through natural dialogue with an anime character.

[0408] "Collection means" refers to the function for obtaining data from websites and APIs and accumulating the necessary information.

[0409] "Preprocessing means" is a function that cleans up collected data and prepares it in a format suitable for analysis and learning.

[0410] "Learning tools" are functions for training generative AI models based on collected and preprocessed data.

[0411] The "analysis means" is a function for interpreting request messages and data sent by users and understanding their intent and content.

[0412] The "response generation means" is a function that generates an appropriate response based on the results of emotion analysis, and realizes a dialogue based on the character's characteristics and the user's emotions.

[0413] The "emotion analysis means" is a function for identifying emotions from a user's message and using that information for analysis.

[0414] The "virtual store means for supporting user purchasing behavior through dialogue" is a function that provides a virtual store where users can select and purchase products through dialogue with characters.

[0415] The "display means" is a function for providing a user interface and visually displaying message inputs and responses from the server.

[0416] The present invention provides a system for supporting the process of a user selecting and purchasing a product in a virtual store through interaction with an animated character. The system includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, a sentiment analysis means, a virtual store means for supporting the user's purchasing behavior through interaction, and a display means.

[0417] Processing performed by the server

[0418] Collection Method

[0419] The server first collects the lines of the anime and related data from websites and APIs, such as lines related to a specific character or product information, and stores them in a database.

[0420] Pretreatment means

[0421] The collected data is cleaned, de-noised, and formatted, for example by removing unnecessary information from dialogue data and tokenizing text data to convert it into a format suitable for analysis.

[0422] Learning tools

[0423] The preprocessed data is used to train a generative AI model, which then learns the character's unique speech patterns and thought patterns. For example, the model learns what words a particular character uses in what situations, and then reproduces the character's characteristics.

[0424] Analysis means

[0425] It receives request messages sent by users and analyzes their contents. For example, if a user sends a message saying "I'm looking for a new manga," it analyzes the message as a question to the character.

[0426] Emotion analysis means

[0427] The emotion engine is used to analyze the emotion of a user message. For example, if a user sends a message saying "I'm so excited!", the emotion engine will identify "excited" as the emotion.

[0428] Response Generation Method

[0429] Based on the results of the sentiment analysis, a generative AI model of the target character is used to generate an appropriate response to the user's message. For example, if a user says, "I'm looking for a new manga," the character will respond with, "Here are some recommended titles," and provide a list of related products.

[0430] Processing performed by the device

[0431] Display means

[0432] A chat interface is provided for users to interact with characters. This interface includes a message input field and a send button. For example, a chat window is displayed on a smartphone application.

[0433] Accepting and sending user input

[0434] When a user inputs a message and presses the send button, the message is sent to the server. For example, a user inputs "I'm looking for new manga" and presses the send button.

[0435] Response from the server

[0436] The response message received from the server is displayed in the chat interface. For example, a character may respond with "This is the recommended title."

[0437] Specific examples

[0438] Users can access a virtual store and enjoy interactive shopping. When a user tells a character, "I'm looking for a new manga," the character will respond with, "Here are some recommended titles," and suggest a list of related products. This process generates a response based on the user's emotions, allowing the user to enjoy a highly personalized shopping experience.

[0439] An example of a prompt is

[0440] User types: "I'm looking for new manga."

[0441] The character responds: "Here's a recommended title."

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

[0443] Step 1:

[0444] The server uses collection tools to obtain dialogue data and product information related to anime characters from websites and APIs. Specifically, it obtains data from APIs and stores it in a database. The input is a URL or API endpoint, and the output is the data that is stored in the database.

[0445] Step 2:

[0446] The server uses preprocessing tools to clean up the collected data and prepare it in a format suitable for analysis and learning. Specifically, it removes unnecessary information and tokenizes the text data. The input is the collected data, and the output is the cleaned text data.

[0447] Step 3:

[0448] The server uses a learning mechanism to train a generative AI model using the preprocessed data. Specifically, it uses the data as a training dataset to generate a model that learns the character's unique speech and thought patterns. The input is the preprocessed data, and the output is a trained generative AI model.

[0449] Step 4:

[0450] The device provides a user interface that allows users to initiate a conversation. Specifically, the chat interface displays a message input field and a send button. The input is the user interface design, and the output is the on-screen chat window.

[0451] Step 5:

[0452] When a user enters a message and presses the send button, the device sends the message to the server. Specifically, the device sends the user's input data as an API request. The input is the text message entered by the user, and the output is the request sent to the server.

[0453] Step 6:

[0454] The server uses an analysis method to analyze the request message from the user. Specifically, it performs natural language processing to interpret the message content and understand its intent. The input is the user's message, and the output is the result of analyzing the message content.

[0455] Step 7:

[0456] The server uses an emotion analysis means to analyze the emotion of the user message. Specifically, it uses an emotion engine to extract emotion data from the message. The input is the analyzed user message, and the output is the emotion data.

[0457] Step 8:

[0458] The server uses a response generation means to generate an appropriate response using a generative AI model based on the results of emotion analysis. Specifically, a response based on the user's emotion and the message content is generated from the generative model. The inputs are emotion data and the analyzed message, and the output is a generated response message.

[0459] Step 9:

[0460] The server generates a response message and sends it to the terminal. The response message is the input, and the transmission to the terminal is the output.

[0461] Step 10:

[0462] The terminal uses a display means to display the received response message in the chat interface. Specifically, the response message is displayed in a form that is visible to the user. The input is the message received from the server, and the output is the response displayed in the chat window.

[0463] Step 11:

[0464] The user can review the displayed response and continue the conversation as needed. For example, if the user types "I'm looking for a new manga" and the character responds with "Here are some recommended titles," the user can ask more specific questions or make selections.

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

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

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

[0468] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0481] The system of the present invention allows users to naturally interact with anime characters and historical figures, and is realized by the following means: First, the processing performed by the server will be described.

[0482] Processing performed by the server

[0483] Obtaining character data

[0484] The server collects relevant data, such as lines from anime or biographies of historical figures, from websites and APIs. The server then stores the collected data. The server also manages the collected data using a database. For example, the server obtains line data related to a specific character and stores it in the database.

[0485] Data Preprocessing

[0486] The server cleans the collected data and removes unnecessary data and noise. To do this, the server performs data formatting. Specifically, it tokenizes and normalizes the text data to make it easier to analyze. For example, it removes noise and inappropriate expressions from the acquired dialogue data.

[0487] Training generative AI models

[0488] The server uses the preprocessed data to train a generative AI model, using artificial intelligence technology to learn the character's speech patterns and thought patterns. For example, the model learns what words a particular character uses in what situations. This learning process makes it possible to faithfully reproduce the character's characteristics.

[0489] Parsing user requests

[0490] The server receives the request message sent by the user and analyzes its contents. This analysis determines which character the request is directed to and the intent of the request. For example, if a user sends a message saying "How was your day?", the message is analyzed as a question for a specific character.

[0491] Generate and send a response

[0492] The server uses an appropriate character generation AI model based on the analysis results to generate a response to the user's message. This response realizes natural dialogue based on the character's characteristics. The generated response is sent from the server to the user's device. For example, a model of Sakata Gintoki might respond to a user's question by saying, "I spent today watching movies."

[0493] Processing performed by the device

[0494] Providing a user interface

[0495] The terminal displays a chat interface for the user to interact with the character. In this interface, the user can input and send messages. For example, a chat window is displayed on a smartphone application.

[0496] Accepting and sending user input

[0497] The terminal prepares to send the message entered by the user to the server. When the user enters a message and presses the send button, the message is sent from the terminal to the server. For example, the user enters "What is your favorite food?" and presses the send button.

[0498] Response from the server

[0499] The device displays the response message received from the server on the chat interface. The received message is displayed in a form visible to the user, and a dialogue takes place. For example, a response such as "My favorite food is dumplings" is displayed.

[0500] User actions

[0501] Character Selection

[0502] The user selects the character they want to chat with from a list of characters provided on the platform. For example, the user selects Sakata Gintoki and starts chatting.

[0503] Starting and continuing a chat conversation

[0504] The user enters a message and presses the send button to begin a conversation with the selected character. Once the conversation begins, the user can continue to ask questions and receive responses. For example, the user can enter "How was your day?" and receive a response from the character saying "I spent today watching movies."

[0505] The present invention, as described above, allows users to enjoy natural conversations with their favorite characters and historical figures, and also provides a platform where users can create and sell their own original characters, thereby meeting a variety of needs.

[0506] The processing flow will be explained below.

[0507] Step 1:

[0508] Data collection (server)

[0509] The server collects relevant data, such as anime lines or biographies of historical figures, from websites and APIs, and stores the collected data in a database.

[0510] Step 2:

[0511] Data preprocessing (server)

[0512] The server cleans and formats the collected data, removing unnecessary data and noise, and tokenizing and normalizing the text data.

[0513] Step 3:

[0514] Creating a dataset (server)

[0515] The server creates a training dataset based on the preprocessed data, extracting data related to specific characters and formatting it for training.

[0516] Step 4:

[0517] Training generative AI models (server)

[0518] The server uses the created dataset to train a generative AI model, which in turn learns the character's unique speech patterns and thought patterns.

[0519] Step 5:

[0520] Receiving user requests (server)

[0521] The server receives messages from users, for example, messages that users type into a chat window are sent to the server.

[0522] Step 6:

[0523] Request analysis (server)

[0524] The server analyzes the received message and identifies the message content and target character using natural language processing technology.

[0525] Step 7:

[0526] Response generation (server)

[0527] The server uses the AI ​​model of the identified character to generate a response to the user's message, where the generated response is based on the character's characteristics.

[0528] Step 8:

[0529] Response sending (server)

[0530] The server then sends the generated response to the user's terminal in a format that will be displayed in the user's chat window.

[0531] Step 9:

[0532] User interface display (terminal)

[0533] The device displays a chat interface for the user, which includes a message entry field and a send button.

[0534] Step 10:

[0535] Accepting user input (terminal)

[0536] When the user inputs a message and presses the send button, the terminal transmits the input message to the server.

[0537] Step 11:

[0538] Display of response message (terminal)

[0539] The terminal displays the response message received from the server on the chat interface, and the user can see the character's response through the terminal.

[0540] Step 12:

[0541] Character Selection (User)

[0542] Users select the character they want to chat with from a list on the platform, and a conversation begins based on the selected character.

[0543] Step 13:

[0544] Continue chat (user)

[0545] The user can continue to interact with the character by typing messages and periodically sending new messages, receiving replies from the character, and continuing the conversation.

[0546] Example 1

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

[0548] Currently, many users desire to converse naturally with their favorite anime characters or historical figures, but existing systems have difficulty fully reproducing the natural conversational abilities of characters. Furthermore, building a dialogue system using a generative AI model requires the collection and preprocessing of a huge amount of data, and efficient methods for doing this are needed. Furthermore, the ease of use of the user interface and the generation of responses in real time are also important issues.

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

[0550] In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, and a display means. This allows natural language data to be collected from websites and APIs, and preprocessed through cleaning, tokenization, and normalization. The preprocessed data can then be used to train a generative AI model, which can generate and send appropriate responses based on user requests, enabling natural interactions between the user and the character.

[0551] "Collection Methods" are the methods used to collect natural language data from websites and APIs.

[0552] The "preprocessing means" is a means for tokenizing, normalizing, and cleaning the collected data.

[0553] A "learning means" is a means for training a generative AI model using preprocessed data.

[0554] The "analysis means" is a means for receiving a request message from a user and analyzing the content related to the character.

[0555] "Response generation means" refers to a means for generating an appropriate response using a generative AI model based on the analysis results.

[0556] The "display means" is a means for transmitting the generated response to the user terminal and displaying it.

[0557] The system of the present invention allows users to naturally interact with anime characters and historical figures, and is realized by the following means: Specifically, the entire system functions by the server, terminal, and user fulfilling their respective roles.

[0558] Server processing

[0559] Obtaining character data

[0560] The server uses the Python requests library to collect natural language data from websites and APIs. For example, it can retrieve lines from anime characters or biographical data from historical documents, and store the data in a database such as MongoDB. This data collection creates a language database for each character.

[0561] Data Preprocessing

[0562] The server preprocesses the collected data using data processing libraries such as Pandas and Numpy. This preprocessing includes cleaning, tokenizing, and normalizing the data. For example, it removes unnecessary HTML tags and special characters from the acquired text data to make it easier to analyze.

[0563] Training generative AI models

[0564] The server uses the preprocessed data to train a generative AI model. This process uses generative AI models such as GPT-3 and BERT and deep learning frameworks such as TensorFlow and PyTorch. For example, the server can learn the speech patterns of anime characters or statements by historical figures and use them to generate responses.

[0565] Parsing user requests

[0566] The server receives the request message sent by the user and analyzes its content using natural language processing technology. For example, when a user sends a message such as "How was your day?", the server analyzes the message and processes it as a question related to a specific character.

[0567] Generate and send a response

[0568] The server uses an appropriate generative AI model based on the analysis results to generate a response to the user's message. The generated response is then sent from the server to the user's device. For example, a model of an anime character might generate a response such as "I spent today watching a movie" and send it.

[0569] Processing by the terminal

[0570] Providing a user interface

[0571] The terminal displays a chat interface that allows the user to interact with the character, for example, by displaying a chat window on a smartphone application, allowing the user to enter messages.

[0572] Accepting and sending user input

[0573] The terminal sends the message entered by the user to the server. For example, if the user enters "What is your favorite food?" and presses the send button, the message is sent from the terminal to the server.

[0574] Response from the server

[0575] The device displays the response message received from the server in the chat interface, for example, the message "My favorite food is dumplings."

[0576] User operation

[0577] Character Selection

[0578] The user selects from a list of characters with whom they want to chat, for example, the user selects a particular character and types a message to begin chatting.

[0579] Starting and continuing a chat conversation

[0580] The user enters a message and presses the send button to begin a conversation with the selected character. Once the conversation begins, the user can continue to ask questions and receive responses. For example, the user can enter "How was your day?" and receive a response from the character saying "I spent today watching movies."

[0581] Examples of prompt statements

[0582] For example, a dialogue with a character can be realized using the following prompt sentence:

[0583] The user types, "What is your favorite food?"

[0584] The server consults the character's dialogue database and generates an appropriate response.

[0585] Generated response: "My favorite food is dango."

[0586] This system allows users to enjoy natural conversations with anime characters and historical figures, and uses natural language processing technology with generative AI models to enable real-time conversations.

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

[0588] Step 1: Obtaining Character Data

[0589] The server collects natural language data from websites and APIs. It uses Python's requests library to send HTTP requests to API endpoints and retrieves JSON data as a response. For example, it retrieves lines from anime characters or biographies of historical figures from the API and stores them in a local database (e.g., MongoDB). Inputs include the API URL and query parameters, and the retrieved natural language data is stored in the database as output.

[0590] Step 2: Preprocessing the data

[0591] The server cleans, tokenizes, and normalizes the collected natural language data. For data preprocessing, it uses data processing libraries such as Pandas and Numpy. Specifically, it removes HTML tags and special characters from the collected text data to obtain formatted text data. For example, Hello " is converted into a clean form like "Hello." The input is natural language data in JSON format, and the output is cleaned, tokenized, and normalized text data.

[0592] Step 3: Training the generative AI model

[0593] The server uses the preprocessed data to train a generative AI model. This model training uses a deep learning framework such as TensorFlow or PyTorch. As a specific example, to learn the speech patterns of anime characters, the preprocessed data is input to the model as a dataset and training is performed through multiple epochs. The inputs are the cleaned text data and the model's hyperparameters, and the output is a trained generative AI model.

[0594] Step 4: Parsing the user request

[0595] The server analyzes the request message received from the user. Using natural language processing technology (e.g., spaCy or NLTK), it tokenizes the user's input message and identifies its intent and the target character. For example, if a user sends a message saying, "How was your day?", the intent of the question is analyzed and it is determined that the question is related to Sakata Gintoki. The input is the user's message, and the output is the analyzed intent and information about the target character.

[0596] Step 5: Generate and send a response

[0597] The server uses an appropriate generative AI model based on the analysis results to generate a response to the user message. The generated response is sent from the server to the user's device. For example, Sakata Gintoki's generative AI model generates a response such as "I spent today watching a movie" and sends it to the user's device. The inputs are the analysis results and the generative AI model, and the output is the generated response message sent to the user's device.

[0598] Step 6: Providing a User Interface

[0599] The terminal displays a chat interface that allows the user to interact with the character. This interface allows the user to input and send messages. For example, a chat window may be displayed on a smartphone application, allowing the user to input messages in an input field. The input includes interface design information for the application, and the output is the displayed chat interface provided to the user.

[0600] Step 7: Accepting and Sending User Input

[0601] The terminal sends messages entered by the user to the server. When the user enters a message and presses the send button, the message is sent from the terminal to the server and passed to the server for processing. For example, when the user enters "What is your favorite food?" and presses the send button, the message is sent from the terminal to the server. As input we have the user's message and as output we have the sent message sent to the server.

[0602] Step 8: View the response from the server

[0603] The terminal displays the response message received from the server in the chat interface. For example, the terminal receives a response message from the server saying "My favorite food is dumplings" and displays it to the user. The response message received from the server is the input, and the response displayed in the chat interface is the output provided to the user.

[0604] This series of processes allows users to enjoy natural conversations with anime characters and historical figures.

[0605] (Application example 1)

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

[0607] Today's users demand richer, more interactive experiences than simple text or voice chat. However, existing systems struggle to deliver real-time responses that match the character's personality and voice. They also lack the history management capabilities to enable users to review past conversations and enjoy long-term interactions with the character. This calls for new ways to improve user satisfaction and the quality of entertainment.

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

[0609] In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, a display means, a means for playing back a response message on a terminal using a speech synthesis engine, a communication means for processing user messages in real time, and a history management means for managing dialogue with characters. This allows users to enjoy natural dialogue with unique characters in real time and also allows them to look back on past dialogue history.

[0610] "Collection means" is the function that collects necessary data from websites and APIs and stores it in a database.

[0611] "Preprocessing means" is a function that cleans collected data, tokenizes and normalizes it, and prepares text data in an analyzable format.

[0612] "Learning tools" are functions that use pre-processed data to train a generative AI model to learn the character's speech patterns and thought patterns.

[0613] "Analysis means" is a function that analyzes messages sent by users and understands the intent of the request and the target character.

[0614] The "response generation means" is a function that uses a generative AI model based on the analysis results to generate an appropriate response to a user message.

[0615] The "display means" is a function that displays the generated response message on the user device.

[0616] A "voice synthesis engine" is a technology that converts text data into speech in the voice of a specified character and plays it back in a natural voice.

[0617] The "communication means" is a function that sends messages from users to a server and transmits responses generated by the server to user terminals in real time.

[0618] The "history management means" is a function that stores the history of interactions with characters and allows the user to refer to that history at any time.

[0619] This invention is a system that allows users to enjoy natural conversations with anime characters and historical figures. An example of this system is shown below.

[0620] System Configuration

[0621] This system consists of a server and a user terminal. The server includes a collection means, a preprocessing means, a learning means, a analyzing means, a response generation means, and a speech synthesis engine. The user terminal includes a display means, a user interface, a communication means, and a history management means.

[0622] Server Processing

[0623] 1. Collection Method:

[0624] The server collects data such as anime dialogue and biographies of historical figures from websites and APIs, and stores it in a database, where dialogue data is organized by character.

[0625] 2. Pretreatment methods:

[0626] The server cleans the collected data, tokenizing and normalizing it, which removes noise from the text data and makes it parseable.

[0627] 3. Learning tools:

[0628] The preprocessed data is used to train a generative AI model, which then learns the character's speaking style and thought patterns, enabling it to generate natural-looking dialogue.

[0629] 4. Analysis method:

[0630] The server analyzes messages sent by users and understands their intent. For example, a message like "How was your day?" is recognized as a question for a specific character.

[0631] 5. Response Generation Methods:

[0632] Based on the analysis results, an appropriate character generation AI model is used to generate a response to the user's message, for example, "I spent today watching movies."

[0633] 6. Speech synthesis engine:

[0634] The generated response is synthesized into a voice using the specified character's voice and played back as a natural voice.

[0635] User terminal processing

[0636] 1. Display and User Interface:

[0637] The user terminal provides a chat interface for interaction, where users can type and send messages.

[0638] 2. Means of communication:

[0639] A message entered by the user is transmitted to the server via the communication means, and a response generated by the server is transmitted to the user terminal via the communication means again.

[0640] 3. History Management Methods:

[0641] The device stores the history of interactions with the character, allowing the user to refer to past interactions at any time.

[0642] Hardware and software used

[0643] Smartphones, smart glasses, head-mounted displays: used as user devices.

[0644] Text analysis libraries (e.g. spaCy): Used to preprocess data.

[0645] Generative AI model (e.g. GPT): Used as a generative AI model.

[0646] A speech synthesis engine (e.g., Amazon Polly): Used for speech synthesis.

[0647] Specific examples

[0648] When a user interacts with a character named Sakata Gintoki, the user inputs and sends the message "How was your day?". An example of a prompt sentence is "When you ask Sakata Gintoki, "How was your day?", generate a response from his character model."

[0649] This allows the system to generate a response such as "I spent today watching movies," which can be displayed on the user's device and played back as audio.

[0650] Thus, the system of the present invention allows users to enjoy natural and interactive dialogue with anime characters and historical figures.

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

[0652] Step 1:

[0653] Collecting character data

[0654] The server collects data such as anime dialogue and biographies of historical figures from websites and APIs, and organizes this data by character and stores it in a database.

[0655] Input: Text data obtained from a website or API

[0656] Output: Raw data stored in a database

[0657] Specific operation: The server accesses a specific URL and retrieves the lines and information of each character. The retrieved data is then stored directly in the database.

[0658] Step 2:

[0659] Data Preprocessing

[0660] The server cleans the collected data, tokenizing and normalizing it, which removes noise from the text data and puts it into a format that can be analyzed.

[0661] Input: Raw data stored in a database

[0662] Output: Preprocessed, clean text data

[0663] What it does: The server uses a text analysis library (e.g. spaCy) to tokenize the text and remove unnecessary noise and profanity.

[0664] Step 3:

[0665] Training generative AI models

[0666] The server uses the preprocessed data to train a generative AI model (e.g., GPT), which learns the character's speaking style and thought patterns, enabling it to generate natural dialogue.

[0667] Input: Preprocessed text data

[0668] Output: A trained generative AI model

[0669] Specific operation: The server uses an AI learning framework (e.g., TensorFlow) to input the preprocessed data into an AI model to learn the character's characteristics.

[0670] Step 4:

[0671] Parsing user requests

[0672] The server analyzes messages sent by users and understands their intent. For example, a message like "How was your day?" is recognized as a question to a specific character.

[0673] Input: Message from user

[0674] Output: Analyzed intent and target character

[0675] Specific operation: The server uses natural language processing (NLP) algorithms to analyze the user message and identify the message's intent and target characters.

[0676] Step 5:

[0677] Generating a response

[0678] The server uses the analysis results to generate a response to the user's message using an appropriate character generation AI model, for example, "I spent today watching movies."

[0679] Input: Analysis results and generated AI model

[0680] Output: The generated text response

[0681] Specific operation: The server inputs a prompt sentence into the generative AI model and generates a corresponding response for each character.

[0682] Step 6:

[0683] Speech synthesis

[0684] The server synthesizes the generated response in the voice of the specified character and plays it back as a natural voice.

[0685] Input: Generated text response

[0686] Output: A synthesized response

[0687] What happens: The server uses a speech synthesis engine (e.g., Amazon Polly) to convert the generated text response into audio data.

[0688] Step 7:

[0689] Response display on user terminal

[0690] The user terminal displays the response received from the server on the user interface.

[0691] Input: Text and audio data from the server

[0692] Output: Display and audio playback in the chat interface

[0693] Specific behavior: Display the response text in the chat interface and play the synthesized voice from the audio speaker.

[0694] Step 8:

[0695] History and Reference

[0696] The user terminal stores a history of interactions with the character, allowing the user to refer to past interactions at any time.

[0697] Input: Response and user message data

[0698] Output: Saved interaction history

[0699] Specific behavior: Each time a conversation is completed, the message and response are saved in a database, and past conversations are displayed when the user opens the history screen.

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

[0701] The system of the present invention not only allows users to naturally interact with anime characters and historical figures, but also recognizes the user's emotions and generates responses based on those emotions. The following describes in detail each means and operation of the system.

[0702] Processing performed by the server

[0703] Obtaining character data

[0704] The server collects relevant data, such as lines from anime or biographies of historical figures, from websites and APIs. The collected data is stored in a database. For example, it retrieves the lines related to a specific character and stores them in the database.

[0705] Data Preprocessing

[0706] The server cleans and formats the collected data. Specifically, it removes unnecessary data and noise, and tokenizes and normalizes the text data. This makes the data easier to analyze. For example, it removes noise from dialogue data and formats it in a format suitable for analysis.

[0707] Training generative AI models

[0708] The server uses the preprocessed data to train a generative AI model, which then learns the character's unique speech patterns and thought patterns. For example, the AI ​​model learns what words a particular character uses in what situations, and then reproduces the character's characteristics.

[0709] Parsing user requests

[0710] The server receives the request message sent by the user and analyzes its contents. This analysis determines which character the request is directed to and the intent of the request. For example, if a user sends a message saying "How was your day?", the message is analyzed as a question for a specific character.

[0711] Emotion analysis

[0712] The server analyzes the emotion of a user message using an emotion engine. The emotion engine identifies emotions from the text content and provides the information to the analysis means. For example, if a user sends a message saying "I'm happy!", the emotion engine identifies "joy" as the emotion.

[0713] Generate and send a response

[0714] Based on the results of the emotion analysis, the server uses a generative AI model of the target character to generate an appropriate response to the user's message. The generated response is based on the character's characteristics and the user's emotions. The response is sent from the server to the user's device. For example, if a user sends a message saying, "I feel sad," the model of Sakata Gintoki will respond with, "I see, that must have been tough. But I'm sure something good will happen tomorrow!"

[0715] Processing performed by the device

[0716] Providing a user interface

[0717] The device displays a chat interface that allows the user to interact with the character. This interface includes a message input field and a send button. For example, a chat window is displayed on a smartphone application.

[0718] Accepting and sending user input

[0719] When a user inputs a message and presses the send button, the terminal sends the input message to the server. For example, a user inputs "How was your day today?" and presses the send button.

[0720] Response from the server

[0721] The device displays the response message received from the server in the chat interface. The response message is displayed in a visible form to the user. For example, a response such as "Today was busy, but it was fun!" may be displayed.

[0722] User actions

[0723] Character Selection

[0724] Users can select a character they want to chat with from a list on the platform, and a conversation will begin based on the selected character. For example, a user can select Sakata Gintoki from the list and start chatting.

[0725] Continue chatting

[0726] The user can continue the conversation by typing messages and periodically sending new messages to the character. The character will then respond and the conversation can continue. For example, the user can type "How are you doing lately?", and the character will respond with "I'm fine, how about you?"

[0727] The present invention, as described above, allows users to enjoy natural conversations with their favorite characters and historical figures. Furthermore, the quality of the conversation can be improved by recognizing the user's emotions and generating responses based on those emotions. Furthermore, the present invention can meet a variety of needs by providing a platform where users can create and sell their own unique characters.

[0728] The processing flow will be explained below.

[0729] Step 1:

[0730] Data collection (server)

[0731] The server collects relevant data, such as lines from anime or biographies of historical figures, from websites and APIs. The collected data is stored in a database. For example, it retrieves the lines related to a specific character and stores them in the database.

[0732] Step 2:

[0733] Data preprocessing (server)

[0734] The server cleans and formats the collected data. Specifically, it removes unnecessary data and noise, and tokenizes and normalizes the text data. This makes the data easier to analyze. For example, it removes noise from dialogue data and formats it in a format suitable for analysis.

[0735] Step 3:

[0736] Creating a dataset (server)

[0737] The server creates a training dataset based on the preprocessed data. It extracts data related to specific characters and formats it for training purposes. For example, it extracts only the lines of Sakata Gintoki and formats them as a training dataset.

[0738] Step 4:

[0739] Training generative AI models (server)

[0740] The server uses the created dataset to train a generative AI model. During this process, the AI ​​model learns the character's unique speaking and thinking patterns. For example, the AI ​​model learns what words a particular character uses in what situations, and reproduces the character's characteristics.

[0741] Step 5:

[0742] Receiving user requests (server)

[0743] The server receives messages from users, for example, messages that users type into a chat window are sent to the server.

[0744] Step 6:

[0745] Request analysis (server)

[0746] The server analyzes the received message and identifies the message content and the target character. Natural language processing technology is used for the analysis. For example, if a user sends a message saying, "How was your day?", the message is analyzed as a question for a specific character.

[0747] Step 7:

[0748] Sentiment analysis (server)

[0749] The server analyzes the emotion of a user message using an emotion engine. The emotion engine identifies emotions from the text content and provides the information to the analysis means. For example, if a user sends a message saying "I'm happy!", the emotion engine identifies "joy" as the emotion.

[0750] Step 8:

[0751] Response generation (server)

[0752] Based on the results of the emotion analysis, the server uses a generative AI model of the target character to generate an appropriate response to the user's message. The generated response is based on the character's characteristics and the user's emotions. For example, if a user sends a message saying, "I feel sad," the model of Sakata Gintoki will respond with, "I see, that must have been tough. But I'm sure something good will happen tomorrow!"

[0753] Step 9:

[0754] Response sending (server)

[0755] The server then sends the generated response to the user's device. The response message is sent in the format that will be displayed in the user's chat window. For example, in response to the question "How was your day?", "I had a great time today!" is sent to the device.

[0756] Step 10:

[0757] User interface display (terminal)

[0758] The device displays a chat interface that allows the user to interact with the character. This interface includes a message input field and a send button. For example, a chat window is displayed on a smartphone application.

[0759] Step 11:

[0760] Accepting user input (terminal)

[0761] When a user inputs a message and presses the send button, the terminal sends the input message to the server. For example, a user inputs "How was your day today?" and presses the send button.

[0762] Step 12:

[0763] Response display from server (terminal)

[0764] The device displays the response message received from the server in the chat interface. The response message is displayed in a visible form to the user. For example, "How was your day?" is displayed in response to "Today was busy, but fun!"

[0765] Step 13:

[0766] Character Selection (User)

[0767] Users can select a character they want to chat with from a list on the platform, and a conversation will begin based on the selected character. For example, a user can select Sakata Gintoki from the list and start chatting.

[0768] Step 14:

[0769] Continue chat (user)

[0770] The user can continue the conversation by typing messages and periodically sending new messages to the character. The character will then respond and the conversation can continue. For example, the user can type "How are you doing lately?", and the character will respond with "I'm fine, how about you?"

[0771] The present invention, as described above, allows users to enjoy natural conversations with their favorite characters and historical figures. Furthermore, the quality of the conversation can be improved by recognizing the user's emotions and generating responses based on those emotions. Furthermore, the present invention can meet a variety of needs by providing a platform where users can create and sell their own unique characters.

[0772] Example 2

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

[0774] Existing chat systems have made it difficult for users to interact naturally with characters or historical figures. They also lacked the technology to properly recognize users' emotions and generate responses based on them. This limited the user experience and reduced the quality of the interaction.

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

[0776] In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a sentiment analysis means, a response generation means, and a display means, which allows a user to have natural conversations with characters or historical figures and receive responses based on the user's sentiments.

[0777] A "collection method" is a part of a system that automatically retrieves information from websites and data sources and stores it in a database.

[0778] "Preprocessing means" is the part of the system that cleans collected data and processes it through processes such as tokenization and normalization, making it suitable for analysis and model training.

[0779] The "learning means" is the part of the system that uses pre-processed data to train the generative AI model to acquire a character's unique speech patterns and thought patterns.

[0780] The "analysis means" is a part of the system that receives a request sent by a user, analyzes the content of the request, and understands the intent of the message and the person being interacted with.

[0781] The "emotion analysis means" is the part of the system that identifies emotions from users' messages and provides that information to the analysis means.

[0782] A "response generation means" is a part of the system that generates an appropriate response to a user message using a generative AI model based on the results of sentiment analysis.

[0783] The "display means" is a part of the system that provides an interface for interaction between the user and the character, and displays message input and responses from the server.

[0784] The system of the present invention not only allows users to naturally interact with anime characters and historical figures, but also recognizes the user's emotions and generates responses. The following hardware and software are used to implement this system.

[0785] 1. Server

[0786] The server includes a collection means for collecting information from websites and data sources, a pre-processing means for performing pre-processing such as cleaning and tokenizing the data, a learning means for training the generative AI model, an analysis means for analyzing user requests, a sentiment analysis means for performing sentiment analysis, and a response generation means for generating responses to the user.

[0787] Collection Method

[0788] The server uses a Python scraping tool (e.g., BeautifulSoup) to collect data about characters and historical figures from websites, which is then stored in an SQL database.

[0789] Pretreatment means

[0790] The server uses the Python NLTK library to perform data cleaning and text tokenization / normalization. The collected data is then tokenized and normalized to remove unnecessary noise and prepare it in a format suitable for analysis.

[0791] Learning tools

[0792] The server trains a generative AI model (e.g., GPT-3) using TensorFlow or PyTorch, which learns the character's unique speech patterns and language usage, acquiring the character's characteristics.

[0793] Analysis means

[0794] The server uses Natural Language Processing (NLP) technology to analyze the request message from the user. Specifically, it analyzes the message received as an HTTP request and identifies its intent and target.

[0795] Emotion analysis means

[0796] The server analyzes the emotion of the user message using an emotion recognition API (for example, Microsoft Azure's Text Analytics API). The result of the emotion analysis is identified as an emotion such as "joy" or "sadness."

[0797] Response Generation Method

[0798] The server uses a generative AI model to generate an appropriate response based on the results of emotion analysis. For example, if a user enters "I was sad today," the server generates a response such as "That was tough, but I'm sure good things will happen tomorrow!"

[0799] 2. Terminal

[0800] The terminal provides an interface for users to interact with characters, and has the following main functions:

[0801] Providing a user interface

[0802] The device uses a mobile application framework (e.g., React Native) to display a chat interface, which includes a message input field and a send button.

[0803] Accepting and sending user input

[0804] When a user enters a message and presses the send button, the device automatically sends the message to the server as an HTTP POST request, triggered by an event listener on the device.

[0805] Response from the server

[0806] The terminal displays the response message received from the server in the chat window. The response message is displayed in real time so that the user can check it immediately.

[0807] 3. Users

[0808] The user interacts with the character via the terminal.

[0809] Character Selection

[0810] Users select the character they want to interact with from a list on the platform, and then the interaction begins.

[0811] Enter and send a message

[0812] The user enters a message to continue the conversation and presses the send button, for example, "How was your day today?" This input is immediately sent to the server.

[0813] Prompt Sentence Examples

[0814] Prompt: "I felt sad."

[0815] Character: fictional character

[0816] Sample response: "I see, that was tough. But I'm sure tomorrow will be better!"

[0817] Based on these steps, users can enjoy natural and emotional interactions with characters and historical figures.

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

[0819] Step 1: Obtaining Character Data

[0820] The server collects data related to characters and historical figures from websites and APIs. A Python scraping tool (e.g., BeautifulSoup) is used as the collection method. A specific URL or API endpoint is specified as input, and dialogue or text data is obtained as output. The collected data is then stored in an SQL database.

[0821] Specifically, the server accesses the specified URL, analyzes the HTML structure, and extracts the required text data. When retrieving data from the API, it requests the data using the API key and parameters, and receives the response.

[0822] Step 2: Preprocessing the data

[0823] The server cleans and preprocesses the collected data. It uses the Python NLTK library as a preprocessing method, taking the collected text data as input and generating tokenized and normalized data as output.

[0824] Specifically, the server removes unnecessary noise and typos from the collected text data, tokenizes the text to break it down into words and phrases, and normalizes the word forms to make them uniform.

[0825] Step 3: Training the generative AI model

[0826] The server uses the preprocessed data to train a generative AI model, using TensorFlow or PyTorch as the learning medium. It provides the preprocessed dataset as input and obtains a trained generative AI model as output.

[0827] Specifically, the server uses the dataset to adjust the model's parameters and train it to learn the character's unique vocabulary and speaking style. This process is repeated, improving the model's accuracy based on a large amount of data.

[0828] Step 4: Receiving and parsing user requests

[0829] The device receives messages from users and sends them to the server. NLP technology is used as the analysis method. The request message from the user is received as input, and the intention of the message and the target character are identified as output.

[0830] Specifically, the device receives the user's message from the message input field and sends it to the server as an HTTP POST request. The server then analyzes the received message and understands its content.

[0831] Step 5: Sentiment Analysis

[0832] The server uses an emotion recognition API to analyze the emotion of the user message. As a means of emotion analysis, it uses Microsoft Azure's Text Analytics API. It receives the user message as input and generates identified emotion information as output.

[0833] Specifically, the server sends the user's text message to an emotion recognition API and identifies the emotion based on the response from the API. For example, the message "I'm happy!" is identified as "joy."

[0834] Step 6: Generate and send a response

[0835] The server uses the generative AI model to generate an appropriate response to the user message. As a response generator, it provides inputs including the results of preprocessing and sentiment analysis, and generates a response message as an output.

[0836] Specifically, the server operates a generative AI model based on the results of emotion analysis to generate an appropriate response. For example, if a user inputs "I was sad today," the system generates a response such as "That was tough, but I'm sure good things will happen tomorrow!" The generated response is then sent from the server to the user's device.

[0837] Step 7: User Interface Display

[0838] The device provides a chat interface for interaction between the user and the character. It uses a mobile application framework such as React Native as the display method. It receives response messages from the server as input and displays them in the chat window as output.

[0839] Specifically, the device receives messages from the server in real time and reflects them on the user interface, allowing the user to instantly see the character's response.

[0840] Step 8: Accepting and Sending User Input

[0841] When the user types a message and presses the send button, the device sends the message to the server. It takes a text message from the user as input and sends it to the server as output.

[0842] Specifically, the user enters the content of the conversation in the message input field and presses the send button. This input information is sent to the server as an HTTP POST request by the terminal.

[0843] Step 9: View the response from the server

[0844] The terminal displays the response message received from the server in the chat interface. It receives the response message from the server as input and displays it in a form that is visible to the user as output.

[0845] Specifically, the terminal reflects the response from the server in the chat window in real time, allowing the user to check it immediately.

[0846] (Application example 2)

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

[0848] Conventional virtual stores have the problem that users cannot receive appropriate support through dialogue when selecting products, which prevents them from fully increasing their purchasing motivation and satisfaction. In addition, they lack a mechanism to provide a more personalized purchasing experience by recognizing users' emotions and generating responses based on them.

[0849] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, an emotion analysis means, a virtual store means for supporting the user's purchasing behavior through dialogue, and a display means. This enables the user to receive a personalized response based on emotion when selecting a product through natural dialogue with an anime character.

[0850] "Collection means" refers to the function for obtaining data from websites and APIs and accumulating the necessary information.

[0851] "Preprocessing means" is a function that cleans up collected data and prepares it in a format suitable for analysis and learning.

[0852] "Learning tools" are functions for training generative AI models based on collected and preprocessed data.

[0853] The "analysis means" is a function for interpreting request messages and data sent by users and understanding their intent and content.

[0854] The "response generation means" is a function that generates an appropriate response based on the results of emotion analysis, and realizes a dialogue based on the character's characteristics and the user's emotions.

[0855] The "emotion analysis means" is a function for identifying emotions from a user's message and using that information for analysis.

[0856] The "virtual store means for supporting user purchasing behavior through dialogue" is a function that provides a virtual store where users can select and purchase products through dialogue with characters.

[0857] The "display means" is a function for providing a user interface and visually displaying message inputs and responses from the server.

[0858] The present invention provides a system for supporting the process of a user selecting and purchasing a product in a virtual store through interaction with an animated character. The system includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, a sentiment analysis means, a virtual store means for supporting the user's purchasing behavior through interaction, and a display means.

[0859] Processing performed by the server

[0860] Collection Method

[0861] The server first collects the lines of the anime and related data from websites and APIs, such as lines related to a specific character or product information, and stores them in a database.

[0862] Pretreatment means

[0863] The collected data is cleaned, de-noised, and formatted, for example by removing unnecessary information from dialogue data and tokenizing text data to convert it into a format suitable for analysis.

[0864] Learning tools

[0865] The preprocessed data is used to train a generative AI model, which then learns the character's unique speech patterns and thought patterns. For example, the model learns what words a particular character uses in what situations, and then reproduces the character's characteristics.

[0866] Analysis means

[0867] It receives request messages sent by users and analyzes their contents. For example, if a user sends a message saying "I'm looking for a new manga," it analyzes the message as a question to the character.

[0868] Emotion analysis means

[0869] The emotion engine is used to analyze the emotion of a user message. For example, if a user sends a message saying "I'm so excited!", the emotion engine will identify "excited" as the emotion.

[0870] Response Generation Method

[0871] Based on the results of the sentiment analysis, a generative AI model of the target character is used to generate an appropriate response to the user's message. For example, if a user says, "I'm looking for a new manga," the character will respond with, "Here are some recommended titles," and provide a list of related products.

[0872] Processing performed by the device

[0873] Display means

[0874] A chat interface is provided for users to interact with characters. This interface includes a message input field and a send button. For example, a chat window is displayed on a smartphone application.

[0875] Accepting and sending user input

[0876] When a user inputs a message and presses the send button, the message is sent to the server. For example, a user inputs "I'm looking for new manga" and presses the send button.

[0877] Response from the server

[0878] The response message received from the server is displayed in the chat interface. For example, a character may respond with "This is the recommended title."

[0879] Specific examples

[0880] Users can access a virtual store and enjoy interactive shopping. When a user tells a character, "I'm looking for a new manga," the character will respond with, "Here are some recommended titles," and suggest a list of related products. This process generates a response based on the user's emotions, allowing the user to enjoy a highly personalized shopping experience.

[0881] An example of a prompt is

[0882] User types: "I'm looking for new manga."

[0883] The character responds: "Here's a recommended title."

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

[0885] Step 1:

[0886] The server uses collection tools to obtain dialogue data and product information related to anime characters from websites and APIs. Specifically, it obtains data from APIs and stores it in a database. The input is a URL or API endpoint, and the output is the data that is stored in the database.

[0887] Step 2:

[0888] The server uses preprocessing tools to clean up the collected data and prepare it in a format suitable for analysis and learning. Specifically, it removes unnecessary information and tokenizes the text data. The input is the collected data, and the output is the cleaned text data.

[0889] Step 3:

[0890] The server uses a learning mechanism to train a generative AI model using the preprocessed data. Specifically, it uses the data as a training dataset to generate a model that learns the character's unique speech and thought patterns. The input is the preprocessed data, and the output is a trained generative AI model.

[0891] Step 4:

[0892] The device provides a user interface that allows users to initiate a conversation. Specifically, the chat interface displays a message input field and a send button. The input is the user interface design, and the output is the on-screen chat window.

[0893] Step 5:

[0894] When a user enters a message and presses the send button, the device sends the message to the server. Specifically, the device sends the user's input data as an API request. The input is the text message entered by the user, and the output is the request sent to the server.

[0895] Step 6:

[0896] The server uses an analysis method to analyze the request message from the user. Specifically, it performs natural language processing to interpret the message content and understand its intent. The input is the user's message, and the output is the result of analyzing the message content.

[0897] Step 7:

[0898] The server uses an emotion analysis means to analyze the emotion of the user message. Specifically, it uses an emotion engine to extract emotion data from the message. The input is the analyzed user message, and the output is the emotion data.

[0899] Step 8:

[0900] The server uses a response generation means to generate an appropriate response using a generative AI model based on the results of emotion analysis. Specifically, a response based on the user's emotion and the message content is generated from the generative model. The inputs are emotion data and the analyzed message, and the output is a generated response message.

[0901] Step 9:

[0902] The server generates a response message and sends it to the terminal. The response message is the input, and the transmission to the terminal is the output.

[0903] Step 10:

[0904] The terminal uses a display means to display the received response message in the chat interface. Specifically, the response message is displayed in a form that is visible to the user. The input is the message received from the server, and the output is the response displayed in the chat window.

[0905] Step 11:

[0906] The user can review the displayed response and continue the conversation as needed. For example, if the user types "I'm looking for a new manga" and the character responds with "Here are some recommended titles," the user can ask more specific questions or make selections.

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

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

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

[0910] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0923] The system of the present invention allows users to naturally interact with anime characters and historical figures, and is realized by the following means: First, the processing performed by the server will be described.

[0924] Processing performed by the server

[0925] Obtaining character data

[0926] The server collects relevant data, such as lines from anime or biographies of historical figures, from websites and APIs. The server then stores the collected data. The server also manages the collected data using a database. For example, the server obtains line data related to a specific character and stores it in the database.

[0927] Data Preprocessing

[0928] The server cleans the collected data and removes unnecessary data and noise. To do this, the server performs data formatting. Specifically, it tokenizes and normalizes the text data to make it easier to analyze. For example, it removes noise and inappropriate expressions from the acquired dialogue data.

[0929] Training generative AI models

[0930] The server uses the preprocessed data to train a generative AI model, using artificial intelligence technology to learn the character's speech patterns and thought patterns. For example, the model learns what words a particular character uses in what situations. This learning process makes it possible to faithfully reproduce the character's characteristics.

[0931] Parsing user requests

[0932] The server receives the request message sent by the user and analyzes its contents. This analysis determines which character the request is directed to and the intent of the request. For example, if a user sends a message saying "How was your day?", the message is analyzed as a question for a specific character.

[0933] Generate and send a response

[0934] The server uses an appropriate character generation AI model based on the analysis results to generate a response to the user's message. This response realizes natural dialogue based on the character's characteristics. The generated response is sent from the server to the user's device. For example, a model of Sakata Gintoki might respond to a user's question by saying, "I spent today watching movies."

[0935] Processing performed by the device

[0936] Providing a user interface

[0937] The terminal displays a chat interface for the user to interact with the character. In this interface, the user can input and send messages. For example, a chat window is displayed on a smartphone application.

[0938] Accepting and sending user input

[0939] The terminal prepares to send the message entered by the user to the server. When the user enters a message and presses the send button, the message is sent from the terminal to the server. For example, the user enters "What is your favorite food?" and presses the send button.

[0940] Response from the server

[0941] The device displays the response message received from the server on the chat interface. The received message is displayed in a form visible to the user, and a dialogue takes place. For example, a response such as "My favorite food is dumplings" is displayed.

[0942] User actions

[0943] Character Selection

[0944] The user selects the character they want to chat with from a list of characters provided on the platform. For example, the user selects Sakata Gintoki and starts chatting.

[0945] Starting and continuing a chat conversation

[0946] The user enters a message and presses the send button to begin a conversation with the selected character. Once the conversation begins, the user can continue to ask questions and receive responses. For example, the user can enter "How was your day?" and receive a response from the character saying "I spent today watching movies."

[0947] The present invention, as described above, allows users to enjoy natural conversations with their favorite characters and historical figures, and also provides a platform where users can create and sell their own original characters, thereby meeting a variety of needs.

[0948] The processing flow will be explained below.

[0949] Step 1:

[0950] Data collection (server)

[0951] The server collects relevant data, such as anime lines or biographies of historical figures, from websites and APIs, and stores the collected data in a database.

[0952] Step 2:

[0953] Data preprocessing (server)

[0954] The server cleans and formats the collected data, removing unnecessary data and noise, and tokenizing and normalizing the text data.

[0955] Step 3:

[0956] Creating a dataset (server)

[0957] The server creates a training dataset based on the preprocessed data, extracting data related to specific characters and formatting it for training.

[0958] Step 4:

[0959] Training generative AI models (server)

[0960] The server uses the created dataset to train a generative AI model, which in turn learns the character's unique speech patterns and thought patterns.

[0961] Step 5:

[0962] Receiving user requests (server)

[0963] The server receives messages from users, for example, messages that users type into a chat window are sent to the server.

[0964] Step 6:

[0965] Request analysis (server)

[0966] The server analyzes the received message and identifies the message content and target character using natural language processing technology.

[0967] Step 7:

[0968] Response generation (server)

[0969] The server uses the AI ​​model of the identified character to generate a response to the user's message, where the generated response is based on the character's characteristics.

[0970] Step 8:

[0971] Response sending (server)

[0972] The server then sends the generated response to the user's terminal in a format that will be displayed in the user's chat window.

[0973] Step 9:

[0974] User interface display (terminal)

[0975] The device displays a chat interface for the user, which includes a message entry field and a send button.

[0976] Step 10:

[0977] Accepting user input (terminal)

[0978] When the user inputs a message and presses the send button, the terminal transmits the input message to the server.

[0979] Step 11:

[0980] Display of response message (terminal)

[0981] The terminal displays the response message received from the server on the chat interface, and the user can see the character's response through the terminal.

[0982] Step 12:

[0983] Character Selection (User)

[0984] Users select the character they want to chat with from a list on the platform, and a conversation begins based on the selected character.

[0985] Step 13:

[0986] Continue chat (user)

[0987] The user can continue to interact with the character by typing messages and periodically sending new messages, receiving replies from the character, and continuing the conversation.

[0988] Example 1

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

[0990] Currently, many users desire to converse naturally with their favorite anime characters or historical figures, but existing systems have difficulty fully reproducing the natural conversational abilities of characters. Furthermore, building a dialogue system using a generative AI model requires the collection and preprocessing of a huge amount of data, and efficient methods for doing this are needed. Furthermore, the ease of use of the user interface and the generation of responses in real time are also important issues.

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

[0992] In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, and a display means. This allows natural language data to be collected from websites and APIs, and preprocessed through cleaning, tokenization, and normalization. The preprocessed data can then be used to train a generative AI model, which can generate and send appropriate responses based on user requests, enabling natural interactions between the user and the character.

[0993] "Collection Methods" are the methods used to collect natural language data from websites and APIs.

[0994] The "preprocessing means" is a means for tokenizing, normalizing, and cleaning the collected data.

[0995] A "learning means" is a means for training a generative AI model using preprocessed data.

[0996] The "analysis means" is a means for receiving a request message from a user and analyzing the content related to the character.

[0997] "Response generation means" refers to a means for generating an appropriate response using a generative AI model based on the analysis results.

[0998] The "display means" is a means for transmitting the generated response to the user terminal and displaying it.

[0999] The system of the present invention allows users to naturally interact with anime characters and historical figures, and is realized by the following means: Specifically, the entire system functions by the server, terminal, and user fulfilling their respective roles.

[1000] Server processing

[1001] Obtaining character data

[1002] The server uses the Python requests library to collect natural language data from websites and APIs. For example, it can retrieve lines from anime characters or biographical data from historical documents, and store the data in a database such as MongoDB. This data collection creates a language database for each character.

[1003] Data Preprocessing

[1004] The server preprocesses the collected data using data processing libraries such as Pandas and Numpy. This preprocessing includes cleaning, tokenizing, and normalizing the data. For example, it removes unnecessary HTML tags and special characters from the acquired text data to make it easier to analyze.

[1005] Training generative AI models

[1006] The server uses the preprocessed data to train a generative AI model. This process uses generative AI models such as GPT-3 and BERT and deep learning frameworks such as TensorFlow and PyTorch. For example, the server can learn the speech patterns of anime characters or statements by historical figures and use them to generate responses.

[1007] Parsing user requests

[1008] The server receives the request message sent by the user and analyzes its content using natural language processing technology. For example, when a user sends a message such as "How was your day?", the server analyzes the message and processes it as a question related to a specific character.

[1009] Generate and send a response

[1010] The server uses an appropriate generative AI model based on the analysis results to generate a response to the user's message. The generated response is then sent from the server to the user's device. For example, a model of an anime character might generate a response such as "I spent today watching a movie" and send it.

[1011] Processing by the terminal

[1012] Providing a user interface

[1013] The terminal displays a chat interface that allows the user to interact with the character, for example, by displaying a chat window on a smartphone application, allowing the user to enter messages.

[1014] Accepting and sending user input

[1015] The terminal sends the message entered by the user to the server. For example, if the user enters "What is your favorite food?" and presses the send button, the message is sent from the terminal to the server.

[1016] Response from the server

[1017] The device displays the response message received from the server in the chat interface, for example, "My favorite food is dumplings."

[1018] User operation

[1019] Character Selection

[1020] The user selects from a list of characters with whom they want to chat, for example, the user selects a particular character and types a message to begin chatting.

[1021] Starting and continuing a chat conversation

[1022] The user enters a message and presses the send button to begin a conversation with the selected character. Once the conversation begins, the user can continue to ask questions and receive responses. For example, the user can enter "How was your day?" and receive a response from the character saying "I spent today watching movies."

[1023] Examples of prompt statements

[1024] For example, a dialogue with a character can be realized using the following prompt sentence:

[1025] The user types, "What is your favorite food?"

[1026] The server consults the character's dialogue database and generates an appropriate response.

[1027] Generated response: "My favorite food is dango."

[1028] This system allows users to enjoy natural conversations with anime characters and historical figures, and uses natural language processing technology with generative AI models to enable real-time conversations.

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

[1030] Step 1: Obtaining Character Data

[1031] The server collects natural language data from websites and APIs. It uses Python's requests library to send HTTP requests to API endpoints and retrieves JSON data as a response. For example, it retrieves lines from anime characters or biographies of historical figures from the API and stores them in a local database (e.g., MongoDB). Inputs include the API URL and query parameters, and the retrieved natural language data is stored in the database as output.

[1032] Step 2: Preprocessing the data

[1033] The server cleans, tokenizes, and normalizes the collected natural language data. For data preprocessing, it uses data processing libraries such as Pandas and Numpy. Specifically, it removes HTML tags and special characters from the collected text data to obtain formatted text data. For example, Hello " is converted into a clean form like "Hello." The input is natural language data in JSON format, and the output is cleaned, tokenized, and normalized text data.

[1034] Step 3: Training the generative AI model

[1035] The server uses the preprocessed data to train a generative AI model. This model training uses a deep learning framework such as TensorFlow or PyTorch. As a specific example, to learn the speech patterns of anime characters, the preprocessed data is input to the model as a dataset and training is performed through multiple epochs. The inputs are the cleaned text data and the model's hyperparameters, and the output is a trained generative AI model.

[1036] Step 4: Parsing the user request

[1037] The server analyzes the request message received from the user. Using natural language processing technology (e.g., spaCy or NLTK), it tokenizes the user's input message and identifies its intent and the target character. For example, if a user sends a message saying, "How was your day?", the intent of the question is analyzed and it is determined that the question is related to Sakata Gintoki. The input is the user's message, and the output is the analyzed intent and information about the target character.

[1038] Step 5: Generate and send a response

[1039] The server uses an appropriate generative AI model based on the analysis results to generate a response to the user message. The generated response is sent from the server to the user's device. For example, Sakata Gintoki's generative AI model generates a response such as "I spent today watching a movie" and sends it to the user's device. The inputs are the analysis results and the generative AI model, and the output is the generated response message sent to the user's device.

[1040] Step 6: Providing a User Interface

[1041] The terminal displays a chat interface that allows the user to interact with the character. This interface allows the user to input and send messages. For example, a chat window may be displayed on a smartphone application, allowing the user to input messages in an input field. The input includes interface design information for the application, and the output is the displayed chat interface provided to the user.

[1042] Step 7: Accepting and Sending User Input

[1043] The terminal sends messages entered by the user to the server. When the user enters a message and presses the send button, the message is sent from the terminal to the server and passed to the server for processing. For example, when the user enters "What is your favorite food?" and presses the send button, the message is sent from the terminal to the server. As input we have the user's message and as output we have the sent message sent to the server.

[1044] Step 8: View the response from the server

[1045] The terminal displays the response message received from the server in the chat interface. For example, the terminal receives a response message from the server saying "My favorite food is dumplings" and displays it to the user. The response message received from the server is the input, and the response displayed in the chat interface is the output provided to the user.

[1046] This series of processes allows users to enjoy natural conversations with anime characters and historical figures.

[1047] (Application example 1)

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

[1049] Today's users demand richer, more interactive experiences than simple text or voice chat. However, existing systems struggle to deliver real-time responses that match the character's personality and voice. They also lack the history management capabilities to enable users to review past conversations and enjoy long-term interactions with the character. This calls for new ways to improve user satisfaction and the quality of entertainment.

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

[1051] In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, a display means, a means for playing back a response message on a terminal using a speech synthesis engine, a communication means for processing user messages in real time, and a history management means for managing dialogue with characters. This allows users to enjoy natural dialogue with unique characters in real time and also allows them to look back on past dialogue history.

[1052] "Collection means" is the function that collects necessary data from websites and APIs and stores it in a database.

[1053] "Preprocessing means" is a function that cleans collected data, tokenizes and normalizes it, and prepares text data in an analyzable format.

[1054] "Learning tools" are functions that use pre-processed data to train a generative AI model to learn the character's speech patterns and thought patterns.

[1055] "Analysis means" is a function that analyzes messages sent by users and understands the intent of the request and the target character.

[1056] The "response generation means" is a function that uses a generative AI model based on the analysis results to generate an appropriate response to a user message.

[1057] The "display means" is a function that displays the generated response message on the user device.

[1058] A "voice synthesis engine" is a technology that converts text data into speech in the voice of a specified character and plays it back in a natural voice.

[1059] The "communication means" is a function that sends messages from users to a server and transmits responses generated by the server to user terminals in real time.

[1060] The "history management means" is a function that stores the history of interactions with characters and allows the user to refer to that history at any time.

[1061] This invention is a system that enables users to enjoy natural conversations with anime characters and historical figures. An example of this system is shown below.

[1062] System Configuration

[1063] This system consists of a server and a user terminal. The server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, and a speech synthesis engine. The user terminal includes a display means, a user interface, a communication means, and a history management means.

[1064] Server Processing

[1065] 1. Collection Method:

[1066] The server collects data such as anime dialogue and biographies of historical figures from websites and APIs, and stores it in a database, where dialogue data is organized by character.

[1067] 2. Pretreatment methods:

[1068] The server cleans the collected data, tokenizing and normalizing it, which removes noise from the text data and makes it parseable.

[1069] 3. Learning medium:

[1070] The preprocessed data is used to train a generative AI model, which then learns the character's speaking style and thought patterns, enabling it to generate natural-looking dialogue.

[1071] 4. Analysis method:

[1072] The server analyzes messages sent by users and understands their intent. For example, a message like "How was your day?" is recognized as a question for a specific character.

[1073] 5. Response Generation Method:

[1074] Based on the analysis results, an appropriate character generation AI model is used to generate a response to the user's message, for example, "I spent today watching movies."

[1075] 6. Speech synthesis engine:

[1076] The generated response is synthesized into a voice using the specified character's voice and played back as a natural voice.

[1077] User terminal processing

[1078] 1. Display and User Interface:

[1079] The user terminal provides a chat interface for interaction, where users can type and send messages.

[1080] 2. Means of communication:

[1081] A message entered by the user is transmitted to the server via the communication means, and a response generated by the server is transmitted to the user terminal via the communication means again.

[1082] 3. History Management Methods:

[1083] The device stores the history of interactions with the character, allowing the user to refer to past interactions at any time.

[1084] Hardware and software used

[1085] Smartphones, smart glasses, head-mounted displays: used as user devices.

[1086] Text analysis libraries (e.g. spaCy): Used to preprocess data.

[1087] Generative AI model (e.g. GPT): Used as a generative AI model.

[1088] A speech synthesis engine (e.g., Amazon Polly): Used for speech synthesis.

[1089] Specific examples

[1090] When a user interacts with a character named Sakata Gintoki, the user inputs and sends the message "How was your day?". An example of a prompt sentence is "When you ask Sakata Gintoki, "How was your day?", generate a response from his character model."

[1091] This allows the system to generate a response such as "I spent today watching movies," which can be displayed on the user's device and played back as audio.

[1092] Thus, the system of the present invention allows users to enjoy natural and interactive dialogue with anime characters and historical figures.

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

[1094] Step 1:

[1095] Collecting character data

[1096] The server collects data such as anime dialogue and biographies of historical figures from websites and APIs, and organizes this data by character and stores it in a database.

[1097] Input: Text data obtained from a website or API

[1098] Output: Raw data stored in a database

[1099] Specific operation: The server accesses a specific URL and retrieves the lines and information of each character. The retrieved data is then stored directly in the database.

[1100] Step 2:

[1101] Data Preprocessing

[1102] The server cleans the collected data, tokenizing and normalizing it, which removes noise from the text data and puts it into a format that can be analyzed.

[1103] Input: Raw data stored in a database

[1104] Output: Preprocessed, clean text data

[1105] What it does: The server uses a text analysis library (e.g. spaCy) to tokenize the text and remove unnecessary noise and profanity.

[1106] Step 3:

[1107] Training generative AI models

[1108] The server uses the preprocessed data to train a generative AI model (e.g., GPT), which learns the character's speaking style and thought patterns, enabling it to generate natural dialogue.

[1109] Input: Preprocessed text data

[1110] Output: A trained generative AI model

[1111] Specific operation: The server uses an AI learning framework (e.g., TensorFlow) to input the preprocessed data into an AI model to learn the character's characteristics.

[1112] Step 4:

[1113] Parsing user requests

[1114] The server analyzes messages sent by users and understands their intent. For example, a message like "How was your day?" is recognized as a question to a specific character.

[1115] Input: Message from user

[1116] Output: Analyzed intent and target character

[1117] Specific operation: The server uses natural language processing (NLP) algorithms to analyze the user message and identify the message's intent and target characters.

[1118] Step 5:

[1119] Generating a response

[1120] The server uses the analysis results to generate a response to the user's message using an appropriate character generation AI model, for example, "I spent today watching movies."

[1121] Input: Analysis results and generated AI model

[1122] Output: The generated text response

[1123] Specific operation: The server inputs a prompt sentence into the generative AI model and generates a corresponding response for each character.

[1124] Step 6:

[1125] Speech synthesis

[1126] The server synthesizes the generated response in the voice of the specified character and plays it back as a natural voice.

[1127] Input: Generated text response

[1128] Output: A synthesized response

[1129] What happens: The server uses a speech synthesis engine (e.g., Amazon Polly) to convert the generated text response into audio data.

[1130] Step 7:

[1131] Response display on user terminal

[1132] The user terminal displays the response received from the server on the user interface.

[1133] Input: Text and audio data from the server

[1134] Output: Display and audio playback in the chat interface

[1135] Specific behavior: Display the response text in the chat interface and play the synthesized voice from the audio speaker.

[1136] Step 8:

[1137] History and Reference

[1138] The user terminal stores a history of interactions with the character, allowing the user to refer to past interactions at any time.

[1139] Input: Response and user message data

[1140] Output: Saved interaction history

[1141] Specific behavior: Each time a conversation is completed, the message and response are saved in a database, and past conversations are displayed when the user opens the history screen.

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

[1143] The system of the present invention not only allows users to naturally interact with anime characters and historical figures, but also recognizes the user's emotions and generates responses based on those emotions. The following describes in detail each means and operation of the system.

[1144] Processing performed by the server

[1145] Obtaining character data

[1146] The server collects relevant data, such as anime dialogue and biographies of historical figures, from websites and APIs. The collected data is stored in a database. For example, it retrieves dialogue data related to a specific character and stores it in the database.

[1147] Data Preprocessing

[1148] The server cleans and formats the collected data. Specifically, it removes unnecessary data and noise, and performs tokenization and normalization of the text data. This makes the data easier to analyze. For example, it removes noise from dialogue data and formats it in a format suitable for analysis.

[1149] Training generative AI models

[1150] The server uses the preprocessed data to train a generative AI model, which then learns the character's unique speech patterns and thought patterns. For example, the AI ​​model learns what words a particular character uses in what situations, and then reproduces the character's characteristics.

[1151] Parsing user requests

[1152] The server receives the request message sent by the user and analyzes its contents. This analysis determines which character the request is directed to and the intent of the request. For example, if a user sends a message saying "How was your day?", the message is analyzed as a question for a specific character.

[1153] Emotion analysis

[1154] The server analyzes the emotion of a user message using an emotion engine. The emotion engine identifies emotions from the text content and provides the information to the analysis means. For example, if a user sends a message saying "I'm happy!", the emotion engine identifies "joy" as the emotion.

[1155] Generate and send a response

[1156] Based on the results of the emotion analysis, the server uses a generative AI model of the target character to generate an appropriate response to the user's message. The generated response is based on the character's characteristics and the user's emotions. The response is sent from the server to the user's device. For example, if a user sends a message saying, "I feel sad," the model of Sakata Gintoki will respond with, "I see, that must have been tough. But I'm sure something good will happen tomorrow!"

[1157] Processing performed by the device

[1158] Providing a user interface

[1159] The device displays a chat interface that allows the user to interact with the character. This interface includes a message input field and a send button. For example, a chat window is displayed on a smartphone application.

[1160] Accepting and sending user input

[1161] When a user inputs a message and presses the send button, the terminal sends the input message to the server. For example, a user inputs "How was your day today?" and presses the send button.

[1162] Response from the server

[1163] The device displays the response message received from the server in the chat interface. The response message is displayed in a visible form to the user. For example, a response such as "Today was busy, but it was fun!" may be displayed.

[1164] User actions

[1165] Character Selection

[1166] Users can select a character they want to chat with from a list on the platform, and a conversation will begin based on the selected character. For example, a user can select Sakata Gintoki from the list and start chatting.

[1167] Continue chatting

[1168] The user can continue the conversation by typing messages and periodically sending new messages to the character. The character will then respond and the conversation can continue. For example, the user can type "How are you doing lately?", and the character will respond with "I'm fine, how about you?"

[1169] The present invention, as described above, allows users to enjoy natural conversations with their favorite characters and historical figures. Furthermore, the quality of the conversation can be improved by recognizing the user's emotions and generating responses based on those emotions. Furthermore, the present invention can meet a variety of needs by providing a platform where users can create and sell their own unique characters.

[1170] The processing flow will be explained below.

[1171] Step 1:

[1172] Data collection (server)

[1173] The server collects relevant data, such as anime dialogue and biographies of historical figures, from websites and APIs. The collected data is stored in a database. For example, it retrieves dialogue data related to a specific character and stores it in the database.

[1174] Step 2:

[1175] Data preprocessing (server)

[1176] The server cleans and formats the collected data. Specifically, it removes unnecessary data and noise, and performs tokenization and normalization of the text data. This makes the data easier to analyze. For example, it removes noise from dialogue data and formats it in a format suitable for analysis.

[1177] Step 3:

[1178] Creating a dataset (server)

[1179] The server creates a training dataset based on the preprocessed data. It extracts data related to specific characters and formats it for training purposes. For example, it extracts only the lines of Sakata Gintoki and formats them as a training dataset.

[1180] Step 4:

[1181] Training generative AI models (server)

[1182] The server uses the created dataset to train a generative AI model. During this process, the AI ​​model learns the character's unique speaking and thinking patterns. For example, the AI ​​model learns what words a particular character uses in what situations, and reproduces the character's characteristics.

[1183] Step 5:

[1184] Receiving user requests (server)

[1185] The server receives messages from users, for example, messages that users type into a chat window are sent to the server.

[1186] Step 6:

[1187] Request analysis (server)

[1188] The server analyzes the received message and identifies the message content and the target character. Natural language processing technology is used for the analysis. For example, if a user sends a message saying, "How was your day?", the message is analyzed as a question for a specific character.

[1189] Step 7:

[1190] Sentiment analysis (server)

[1191] The server analyzes the emotion of a user message using an emotion engine. The emotion engine identifies emotions from the text content and provides the information to the analysis means. For example, if a user sends a message saying "I'm happy!", the emotion engine identifies "joy" as the emotion.

[1192] Step 8:

[1193] Response generation (server)

[1194] Based on the results of the emotion analysis, the server uses a generative AI model of the target character to generate an appropriate response to the user's message. The generated response is based on the character's characteristics and the user's emotions. For example, if a user sends a message saying, "I feel sad," the model of Sakata Gintoki will respond with, "I see, that must have been tough. But I'm sure something good will happen tomorrow!"

[1195] Step 9:

[1196] Response sending (server)

[1197] The server then sends the generated response to the user's device. The response message is sent in the format that will be displayed in the user's chat window. For example, in response to "How was your day?", "I had a great time today!" is sent to the device.

[1198] Step 10:

[1199] User interface display (terminal)

[1200] The device displays a chat interface that allows the user to interact with the character. This interface includes a message input field and a send button. For example, a chat window is displayed on a smartphone application.

[1201] Step 11:

[1202] Accepting user input (terminal)

[1203] When a user inputs a message and presses the send button, the terminal sends the input message to the server. For example, a user inputs "How was your day today?" and presses the send button.

[1204] Step 12:

[1205] Response display from server (terminal)

[1206] The device displays the response message received from the server in the chat interface. The response message is displayed in a visible form to the user. For example, in response to "How was your day?", "Today was busy, but fun!" is displayed.

[1207] Step 13:

[1208] Character Selection (User)

[1209] Users can select a character they want to chat with from a list on the platform, and a conversation will begin based on the selected character. For example, a user can select Sakata Gintoki from the list and start chatting.

[1210] Step 14:

[1211] Continue chat (user)

[1212] The user can continue the conversation by typing messages and periodically sending new messages to the character. The character will then respond and the conversation can continue. For example, the user can type "How are you doing lately?", and the character will respond with "I'm fine, how about you?"

[1213] The present invention, as described above, allows users to enjoy natural conversations with their favorite characters and historical figures. Furthermore, the quality of the conversation can be improved by recognizing the user's emotions and generating responses based on those emotions. Furthermore, the present invention can meet a variety of needs by providing a platform where users can create and sell their own unique characters.

[1214] Example 2

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

[1216] Existing chat systems have made it difficult for users to interact naturally with characters or historical figures. They also lacked the technology to properly recognize users' emotions and generate responses based on them. This limited the user experience and reduced the quality of the interaction.

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

[1218] In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a sentiment analysis means, a response generation means, and a display means, which allows a user to have natural conversations with characters or historical figures and receive responses based on the user's sentiments.

[1219] A "collection method" is a part of a system that automatically retrieves information from websites and data sources and stores it in a database.

[1220] "Preprocessing means" is the part of the system that cleans collected data and processes it through processes such as tokenization and normalization, making it suitable for analysis and model training.

[1221] The "learning means" is the part of the system that uses pre-processed data to train the generative AI model to acquire a character's unique speech patterns and thought patterns.

[1222] The "analysis means" is a part of the system that receives a request sent by a user, analyzes the content of the request, and understands the intent of the message and the person being interacted with.

[1223] The "emotion analysis means" is the part of the system that identifies emotions from users' messages and provides that information to the analysis means.

[1224] A "response generation means" is a part of the system that generates an appropriate response to a user message using a generative AI model based on the results of sentiment analysis.

[1225] The "display means" is a part of the system that provides an interface for interaction between the user and the character, and displays message input and responses from the server.

[1226] The system of the present invention not only allows users to naturally interact with anime characters and historical figures, but also recognizes the user's emotions and generates responses. The following hardware and software are used to implement this system.

[1227] 1. Server

[1228] The server includes a collection means for collecting information from websites and data sources, a pre-processing means for performing pre-processing such as cleaning and tokenizing the data, a learning means for training the generative AI model, an analysis means for analyzing user requests, a sentiment analysis means for performing sentiment analysis, and a response generation means for generating responses to the user.

[1229] Collection Method

[1230] The server uses a Python scraping tool (e.g., BeautifulSoup) to collect data about characters and historical figures from websites, which is then stored in an SQL database.

[1231] Pretreatment means

[1232] The server uses the Python NLTK library to perform data cleaning and text tokenization / normalization. The collected data is then tokenized and normalized to remove unnecessary noise and prepare it in a format suitable for analysis.

[1233] Learning tools

[1234] The server trains a generative AI model (e.g., GPT-3) using TensorFlow or PyTorch, which learns the character's unique speech patterns and language usage, acquiring the character's characteristics.

[1235] Analysis means

[1236] The server uses Natural Language Processing (NLP) technology to analyze the request message from the user. Specifically, it analyzes the message received as an HTTP request and identifies its intent and target.

[1237] Emotion analysis means

[1238] The server analyzes the emotion of the user message using an emotion recognition API (for example, Microsoft Azure's Text Analytics API). The result of the emotion analysis is identified as an emotion such as "joy" or "sadness."

[1239] Response Generation Method

[1240] The server uses a generative AI model to generate an appropriate response based on the results of emotion analysis. For example, if a user enters "I was sad today," the server generates a response such as "That was tough, but I'm sure good things will happen tomorrow!"

[1241] 2. Terminal

[1242] The terminal provides an interface for users to interact with characters, and has the following main functions:

[1243] Providing a user interface

[1244] The device uses a mobile application framework (e.g., React Native) to display a chat interface, which includes a message input field and a send button.

[1245] Accepting and sending user input

[1246] When a user enters a message and presses the send button, the device automatically sends the message to the server as an HTTP POST request, triggered by an event listener on the device.

[1247] Response from the server

[1248] The terminal displays the response message received from the server in the chat window. The response message is displayed in real time so that the user can immediately check it.

[1249] 3. Users

[1250] The user interacts with the character via the terminal.

[1251] Character Selection

[1252] Users select the character they want to interact with from a list on the platform, and then the interaction begins.

[1253] Enter and send a message

[1254] The user enters a message to continue the conversation and presses the send button, for example, "How was your day today?" This input is immediately sent to the server.

[1255] Prompt Sentence Examples

[1256] Prompt: "I felt sad."

[1257] Character: fictional character

[1258] Sample response: "I see, that was tough. But I'm sure tomorrow will be better!"

[1259] Based on these steps, users can enjoy natural and emotional interactions with characters and historical figures.

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

[1261] Step 1: Obtaining Character Data

[1262] The server collects data related to characters and historical figures from websites and APIs. A Python scraping tool (e.g., BeautifulSoup) is used as the collection method. A specific URL or API endpoint is specified as input, and dialogue or text data is obtained as output. The collected data is then stored in an SQL database.

[1263] Specifically, the server accesses the specified URL, analyzes the HTML structure, and extracts the required text data. When retrieving data from the API, it requests the data using the API key and parameters, and receives the response.

[1264] Step 2: Preprocessing the data

[1265] The server cleans and preprocesses the collected data. It uses the Python NLTK library as a preprocessing method, taking the collected text data as input and generating tokenized and normalized data as output.

[1266] Specifically, the server removes unnecessary noise and typos from the collected text data, tokenizes the text to break it down into words and phrases, and normalizes the word forms to make them uniform.

[1267] Step 3: Training the generative AI model

[1268] The server uses the preprocessed data to train a generative AI model, using TensorFlow or PyTorch as the learning medium. It provides the preprocessed dataset as input and obtains a trained generative AI model as output.

[1269] Specifically, the server uses the dataset to adjust the model's parameters and train it to learn the character's unique vocabulary and speaking style. This process is repeated, improving the model's accuracy based on a large amount of data.

[1270] Step 4: Receiving and parsing user requests

[1271] The device receives messages from users and sends them to the server. NLP technology is used as the analysis method. The request message from the user is received as input, and the intention of the message and the target character are identified as output.

[1272] Specifically, the device receives the user's message from the message input field and sends it to the server as an HTTP POST request. The server then analyzes the received message and understands its content.

[1273] Step 5: Sentiment Analysis

[1274] The server uses an emotion recognition API to analyze the emotion of the user message. As a means of emotion analysis, it uses Microsoft Azure's Text Analytics API. It receives the user message as input and generates identified emotion information as output.

[1275] Specifically, the server sends the user's text message to an emotion recognition API and identifies the emotion based on the response from the API. For example, the message "I'm happy!" is identified as "joy."

[1276] Step 6: Generate and send a response

[1277] The server uses the generative AI model to generate an appropriate response to the user message. As a response generator, it provides inputs including the results of preprocessing and sentiment analysis, and generates a response message as an output.

[1278] Specifically, the server operates a generative AI model based on the results of emotion analysis to generate an appropriate response. For example, if a user inputs "I was sad today," the system generates a response such as "That was tough, but I'm sure good things will happen tomorrow!" The generated response is then sent from the server to the user's device.

[1279] Step 7: User Interface Display

[1280] The device provides a chat interface for interaction between the user and the character. It uses a mobile application framework such as React Native as the display method. It receives response messages from the server as input and displays them in the chat window as output.

[1281] Specifically, the device receives messages from the server in real time and reflects them on the user interface, allowing the user to instantly see the character's response.

[1282] Step 8: Accepting and Sending User Input

[1283] When the user types a message and presses the send button, the device sends the message to the server. It takes a text message from the user as input and sends it to the server as output.

[1284] Specifically, the user enters the content of the conversation in the message input field and presses the send button. This input information is sent to the server as an HTTP POST request by the terminal.

[1285] Step 9: View the response from the server

[1286] The terminal displays the response message received from the server in the chat interface. It receives the response message from the server as input and displays it in a form that is visible to the user as output.

[1287] Specifically, the terminal reflects the response from the server in the chat window in real time, allowing the user to check it immediately.

[1288] (Application example 2)

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

[1290] Conventional virtual stores have the problem that users cannot receive appropriate support through dialogue when selecting products, which prevents them from fully increasing their purchasing motivation and satisfaction. In addition, they lack a mechanism to provide a more personalized purchasing experience by recognizing users' emotions and generating responses based on them.

[1291] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, an emotion analysis means, a virtual store means for supporting the user's purchasing behavior through dialogue, and a display means. This enables the user to receive a personalized response based on emotion when selecting a product through natural dialogue with an anime character.

[1292] "Collection means" refers to the function for obtaining data from websites and APIs and accumulating the necessary information.

[1293] "Preprocessing means" is a function that cleans up collected data and prepares it in a format suitable for analysis and learning.

[1294] "Learning tools" are functions for training generative AI models based on collected and preprocessed data.

[1295] The "analysis means" is a function for interpreting request messages and data sent by users and understanding their intent and content.

[1296] The "response generation means" is a function that generates an appropriate response based on the results of emotion analysis, and realizes a dialogue based on the character's characteristics and the user's emotions.

[1297] The "emotion analysis means" is a function for identifying emotions from a user's message and using that information for analysis.

[1298] The "virtual store means for supporting user purchasing behavior through dialogue" is a function that provides a virtual store where users can select and purchase products through dialogue with characters.

[1299] The "display means" is a function for providing a user interface and visually displaying message inputs and responses from the server.

[1300] The present invention provides a system for supporting the process of a user selecting and purchasing a product in a virtual store through interaction with an animated character. The system includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, a sentiment analysis means, a virtual store means for supporting the user's purchasing behavior through interaction, and a display means.

[1301] Processing performed by the server

[1302] Collection Method

[1303] The server first collects the lines of the anime and related data from websites and APIs, such as lines related to a specific character or product information, and stores them in a database.

[1304] Pretreatment means

[1305] The collected data is cleaned, denoised, and formatted, for example by removing unnecessary information from dialogue data and tokenizing text data to convert it into a format suitable for analysis.

[1306] Learning tools

[1307] The preprocessed data is used to train a generative AI model, which then learns the character's unique speech and thought patterns. For example, the model learns what words a particular character uses in what situations, and then reproduces the character's characteristics.

[1308] Analysis means

[1309] It receives request messages sent by users and analyzes their contents. For example, if a user sends a message saying "I'm looking for a new manga," it analyzes the message as a question to the character.

[1310] Emotion analysis means

[1311] The emotion engine is used to analyze the emotion of a user message. For example, if a user sends a message saying "I'm so excited!", the emotion engine will identify "excited" as the emotion.

[1312] Response Generation Method

[1313] Based on the results of the sentiment analysis, a generative AI model of the target character is used to generate an appropriate response to the user's message. For example, if a user says, "I'm looking for a new manga," the character will respond with, "Here are some recommended titles," and provide a list of related products.

[1314] Processing performed by the device

[1315] Display means

[1316] A chat interface is provided for users to interact with characters. This interface includes a message input field and a send button. For example, a chat window is displayed on a smartphone application.

[1317] Accepting and sending user input

[1318] When a user inputs a message and presses the send button, the message is sent to the server. For example, a user inputs "I'm looking for new manga" and presses the send button.

[1319] Response from the server

[1320] The response message received from the server is displayed in the chat interface. For example, a character may respond with "This is the recommended title."

[1321] Specific examples

[1322] Users can access a virtual store and enjoy interactive shopping. When a user says to a character, "I'm looking for a new manga," the character will respond with, "Here are some recommended titles," and suggest a list of related products. This process generates a response based on the user's emotions, allowing the user to enjoy a highly personalized shopping experience.

[1323] An example of a prompt is

[1324] User types: "I'm looking for new manga."

[1325] The character responds: "Here's a recommended title."

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

[1327] Step 1:

[1328] The server uses collection tools to obtain dialogue data and product information related to anime characters from websites and APIs. Specifically, it obtains data from APIs and stores it in a database. The input is a URL or API endpoint, and the output is the data that is stored in the database.

[1329] Step 2:

[1330] The server uses preprocessing tools to clean up the collected data and prepare it in a format suitable for analysis and learning. Specifically, it removes unnecessary information and tokenizes the text data. The input is the collected data, and the output is the cleaned text data.

[1331] Step 3:

[1332] The server uses a learning mechanism to train a generative AI model using the preprocessed data. Specifically, it uses the data as a training dataset to generate a model that learns the character's unique speech and thought patterns. The input is the preprocessed data, and the output is a trained generative AI model.

[1333] Step 4:

[1334] The device provides a user interface that allows users to initiate a conversation. Specifically, the chat interface displays a message input field and a send button. The input is the user interface design, and the output is the on-screen chat window.

[1335] Step 5:

[1336] When a user enters a message and presses the send button, the device sends the message to the server. Specifically, the device sends the user's input data as an API request. The input is the text message entered by the user, and the output is the request sent to the server.

[1337] Step 6:

[1338] The server uses an analysis method to analyze the request message from the user. Specifically, it performs natural language processing to interpret the message content and understand its intent. The input is the user's message, and the output is the result of analyzing the message content.

[1339] Step 7:

[1340] The server uses an emotion analysis means to analyze the emotion of the user message. Specifically, it uses an emotion engine to extract emotion data from the message. The input is the analyzed user message, and the output is the emotion data.

[1341] Step 8:

[1342] The server uses a response generation means to generate an appropriate response using a generative AI model based on the results of emotion analysis. Specifically, a response based on the user's emotion and the message content is generated from the generative model. The inputs are emotion data and the analyzed message, and the output is a generated response message.

[1343] Step 9:

[1344] The server generates a response message and sends it to the terminal. The response message is the input, and the transmission to the terminal is the output.

[1345] Step 10:

[1346] The terminal uses a display means to display the received response message in the chat interface. Specifically, the response message is displayed in a form that is visible to the user. The input is the message received from the server, and the output is the response displayed in the chat window.

[1347] Step 11:

[1348] The user can review the displayed response and continue the conversation as needed. For example, if the user types "I'm looking for a new manga" and the character responds with "Here are some recommended titles," the user can ask more specific questions or make selections.

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

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

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

[1352] [Fourth embodiment]

[1353] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

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

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

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

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

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

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

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

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

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

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

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

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

[1366] The system of the present invention allows users to naturally interact with anime characters and historical figures, and is realized by the following means: First, the processing performed by the server will be described.

[1367] Processing performed by the server

[1368] Obtaining character data

[1369] The server collects relevant data, such as lines from anime or biographies of historical figures, from websites and APIs. The server then stores the collected data. The server also manages the collected data using a database. For example, the server obtains line data related to a specific character and stores it in the database.

[1370] Data Preprocessing

[1371] The server cleans the collected data and removes unnecessary data and noise. To do this, the server performs data formatting. Specifically, it tokenizes and normalizes the text data to make it easier to analyze. For example, it removes noise and inappropriate expressions from the acquired dialogue data.

[1372] Training generative AI models

[1373] The server uses the preprocessed data to train a generative AI model, using artificial intelligence technology to learn the character's speech patterns and thought patterns. For example, the model learns what words a particular character uses in what situations. This learning process makes it possible to faithfully reproduce the character's characteristics.

[1374] Parsing user requests

[1375] The server receives the request message sent by the user and analyzes its contents. This analysis determines which character the request is directed to and the intent of the request. For example, if a user sends a message saying "How was your day?", the message is analyzed as a question for a specific character.

[1376] Generate and send a response

[1377] The server uses an appropriate character generation AI model based on the analysis results to generate a response to the user's message. This response realizes natural dialogue based on the character's characteristics. The generated response is sent from the server to the user's device. For example, a model of Sakata Gintoki might respond to a user's question by saying, "I spent today watching movies."

[1378] Processing performed by the device

[1379] Providing a user interface

[1380] The terminal displays a chat interface for the user to interact with the character. In this interface, the user can input and send messages. For example, a chat window is displayed on a smartphone application.

[1381] Accepting and sending user input

[1382] The terminal prepares to send the message entered by the user to the server. When the user enters a message and presses the send button, the message is sent from the terminal to the server. For example, the user enters "What is your favorite food?" and presses the send button.

[1383] Response from the server

[1384] The device displays the response message received from the server on the chat interface. The received message is displayed in a form visible to the user, and a dialogue takes place. For example, a response such as "My favorite food is dumplings" is displayed.

[1385] User actions

[1386] Character Selection

[1387] The user selects the character they want to chat with from a list of characters provided on the platform. For example, the user selects Sakata Gintoki and starts chatting.

[1388] Starting and continuing a chat conversation

[1389] The user enters a message and presses the send button to begin a conversation with the selected character. Once the conversation begins, the user can continue to ask questions and receive responses. For example, the user can enter "How was your day?" and receive a response from the character saying "I spent today watching movies."

[1390] The present invention, as described above, allows users to enjoy natural conversations with their favorite characters and historical figures, and also provides a platform where users can create and sell their own original characters, thereby meeting a variety of needs.

[1391] The processing flow will be explained below.

[1392] Step 1:

[1393] Data collection (server)

[1394] The server collects relevant data, such as anime lines or biographies of historical figures, from websites and APIs, and stores the collected data in a database.

[1395] Step 2:

[1396] Data preprocessing (server)

[1397] The server cleans and formats the collected data, removing unnecessary data and noise, and tokenizing and normalizing the text data.

[1398] Step 3:

[1399] Creating a dataset (server)

[1400] The server creates a training dataset based on the preprocessed data, extracting data related to specific characters and formatting it for training.

[1401] Step 4:

[1402] Training generative AI models (server)

[1403] The server uses the created dataset to train a generative AI model, which in turn learns the character's unique speech patterns and thought patterns.

[1404] Step 5:

[1405] Receiving user requests (server)

[1406] The server receives messages from users, for example, messages that users type into a chat window are sent to the server.

[1407] Step 6:

[1408] Request analysis (server)

[1409] The server analyzes the received message and identifies the message content and target character using natural language processing technology.

[1410] Step 7:

[1411] Response generation (server)

[1412] The server uses the AI ​​model of the identified character to generate a response to the user's message, where the generated response is based on the character's characteristics.

[1413] Step 8:

[1414] Response sending (server)

[1415] The server then sends the generated response to the user's terminal in a format that will be displayed in the user's chat window.

[1416] Step 9:

[1417] User interface display (terminal)

[1418] The device displays a chat interface for the user, which includes a message entry field and a send button.

[1419] Step 10:

[1420] Accepting user input (terminal)

[1421] When the user inputs a message and presses the send button, the terminal transmits the input message to the server.

[1422] Step 11:

[1423] Display of response message (terminal)

[1424] The terminal displays the response message received from the server on the chat interface, and the user can see the character's response through the terminal.

[1425] Step 12:

[1426] Character Selection (User)

[1427] Users select the character they want to chat with from a list on the platform, and a conversation begins based on the selected character.

[1428] Step 13:

[1429] Continue chat (user)

[1430] The user can continue to interact with the character by typing messages and periodically sending new messages, receiving replies from the character, and continuing the conversation.

[1431] Example 1

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

[1433] Currently, many users desire to converse naturally with their favorite anime characters or historical figures, but existing systems have difficulty fully reproducing the natural conversational abilities of characters. Furthermore, building a dialogue system using a generative AI model requires the collection and preprocessing of a huge amount of data, and efficient methods for doing this are needed. Furthermore, the ease of use of the user interface and the generation of responses in real time are also important issues.

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

[1435] In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, and a display means. This allows natural language data to be collected from websites and APIs, and preprocessed through cleaning, tokenization, and normalization. The preprocessed data can then be used to train a generative AI model, which can generate and send appropriate responses based on user requests, enabling natural interactions between the user and the character.

[1436] "Collection Methods" are the methods used to collect natural language data from websites and APIs.

[1437] The "preprocessing means" is a means for tokenizing, normalizing, and cleaning the collected data.

[1438] A "learning means" is a means for training a generative AI model using preprocessed data.

[1439] The "analysis means" is a means for receiving a request message from a user and analyzing the content related to the character.

[1440] "Response generation means" refers to a means for generating an appropriate response using a generative AI model based on the analysis results.

[1441] The "display means" is a means for transmitting the generated response to the user terminal and displaying it.

[1442] The system of the present invention allows users to naturally interact with anime characters and historical figures, and is realized by the following means: Specifically, the entire system functions by the server, terminal, and user fulfilling their respective roles.

[1443] Server processing

[1444] Obtaining character data

[1445] The server uses the Python requests library to collect natural language data from websites and APIs. For example, it can retrieve lines from anime characters or biographical data from historical documents, and store the data in a database such as MongoDB. This data collection creates a language database for each character.

[1446] Data Preprocessing

[1447] The server preprocesses the collected data using data processing libraries such as Pandas and Numpy. This preprocessing includes cleaning, tokenizing, and normalizing the data. For example, it removes unnecessary HTML tags and special characters from the acquired text data to make it easier to analyze.

[1448] Training generative AI models

[1449] The server uses the preprocessed data to train a generative AI model. This process uses generative AI models such as GPT-3 and BERT and deep learning frameworks such as TensorFlow and PyTorch. For example, the server can learn the speech patterns of anime characters or statements by historical figures and use them to generate responses.

[1450] Parsing user requests

[1451] The server receives the request message sent by the user and analyzes its content using natural language processing technology. For example, when a user sends a message such as "How was your day?", the server analyzes the message and processes it as a question related to a specific character.

[1452] Generate and send a response

[1453] The server uses an appropriate generative AI model based on the analysis results to generate a response to the user's message. The generated response is then sent from the server to the user's device. For example, a model of an anime character might generate a response such as "I spent today watching a movie" and send it.

[1454] Processing by the terminal

[1455] Providing a user interface

[1456] The terminal displays a chat interface that allows the user to interact with the character, for example, by displaying a chat window on a smartphone application, allowing the user to enter messages.

[1457] Accepting and sending user input

[1458] The terminal sends the message entered by the user to the server. For example, if the user enters "What is your favorite food?" and presses the send button, the message is sent from the terminal to the server.

[1459] Response from the server

[1460] The device displays the response message received from the server in the chat interface, for example, "My favorite food is dumplings."

[1461] User operation

[1462] Character Selection

[1463] The user selects from a list of characters with whom they want to chat, for example, the user selects a particular character and types a message to begin chatting.

[1464] Starting and continuing a chat conversation

[1465] The user enters a message and presses the send button to begin a conversation with the selected character. Once the conversation begins, the user can continue to ask questions and receive responses. For example, the user can enter "How was your day?" and receive a response from the character saying "I spent today watching movies."

[1466] Examples of prompt statements

[1467] For example, a dialogue with a character can be realized using the following prompt sentence:

[1468] The user types, "What is your favorite food?"

[1469] The server consults the character's dialogue database and generates an appropriate response.

[1470] Generated response: "My favorite food is dango."

[1471] This system allows users to enjoy natural conversations with anime characters and historical figures, and uses natural language processing technology with generative AI models to enable real-time conversations.

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

[1473] Step 1: Obtaining Character Data

[1474] The server collects natural language data from websites and APIs. It uses Python's requests library to send HTTP requests to API endpoints and retrieves JSON data as a response. For example, it retrieves lines from anime characters or biographies of historical figures from the API and stores them in a local database (e.g., MongoDB). Inputs include the API URL and query parameters, and the retrieved natural language data is stored in the database as output.

[1475] Step 2: Preprocessing the data

[1476] The server cleans, tokenizes, and normalizes the collected natural language data. For data preprocessing, it uses data processing libraries such as Pandas and Numpy. Specifically, it removes HTML tags and special characters from the collected text data to obtain formatted text data. For example, Hello " is converted into a clean form like "Hello." The input is natural language data in JSON format, and the output is cleaned, tokenized, and normalized text data.

[1477] Step 3: Training the generative AI model

[1478] The server uses the preprocessed data to train a generative AI model. This model training uses a deep learning framework such as TensorFlow or PyTorch. As a specific example, to learn the speech patterns of anime characters, the preprocessed data is input to the model as a dataset and training is performed through multiple epochs. The inputs are the cleaned text data and the model's hyperparameters, and the output is a trained generative AI model.

[1479] Step 4: Parsing the user request

[1480] The server analyzes the request message received from the user. Using natural language processing technology (e.g., spaCy or NLTK), it tokenizes the user's input message and identifies its intent and the target character. For example, if a user sends a message saying, "How was your day?", the intent of the question is analyzed and it is determined that the question is related to Sakata Gintoki. The input is the user's message, and the output is the analyzed intent and information about the target character.

[1481] Step 5: Generate and send a response

[1482] The server uses an appropriate generative AI model based on the analysis results to generate a response to the user message. The generated response is sent from the server to the user's device. For example, Sakata Gintoki's generative AI model generates a response such as "I spent today watching a movie" and sends it to the user's device. The inputs are the analysis results and the generative AI model, and the output is the generated response message sent to the user's device.

[1483] Step 6: Providing a User Interface

[1484] The terminal displays a chat interface that allows the user to interact with the character. This interface allows the user to input and send messages. For example, a chat window may be displayed on a smartphone application, allowing the user to input messages in an input field. The input includes interface design information for the application, and the output is the displayed chat interface provided to the user.

[1485] Step 7: Accepting and Sending User Input

[1486] The terminal sends messages entered by the user to the server. When the user enters a message and presses the send button, the message is sent from the terminal to the server and passed to the server for processing. For example, when the user enters "What is your favorite food?" and presses the send button, the message is sent from the terminal to the server. As input we have the user's message and as output we have the sent message sent to the server.

[1487] Step 8: View the response from the server

[1488] The terminal displays the response message received from the server in the chat interface. For example, the terminal receives a response message from the server saying "My favorite food is dumplings" and displays it to the user. The response message received from the server is the input, and the response displayed in the chat interface is the output provided to the user.

[1489] This series of processes allows users to enjoy natural conversations with anime characters and historical figures.

[1490] (Application example 1)

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

[1492] Today's users demand richer, more interactive experiences than simple text or voice chat. However, existing systems struggle to deliver real-time responses that match the character's personality and voice. They also lack the history management capabilities to enable users to review past conversations and enjoy long-term interactions with the character. This calls for new ways to improve user satisfaction and the quality of entertainment.

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

[1494] In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, a display means, a means for playing back a response message on a terminal using a speech synthesis engine, a communication means for processing user messages in real time, and a history management means for managing dialogue with characters. This allows users to enjoy natural dialogue with unique characters in real time and also allows them to look back on past dialogue history.

[1495] "Collection means" is the function that collects necessary data from websites and APIs and stores it in a database.

[1496] "Preprocessing means" is a function that cleans collected data, tokenizes and normalizes it, and prepares text data in an analyzable format.

[1497] "Learning tools" are functions that use pre-processed data to train a generative AI model to learn the character's speech patterns and thought patterns.

[1498] "Analysis means" is a function that analyzes messages sent by users and understands the intent of the request and the target character.

[1499] The "response generation means" is a function that uses a generative AI model based on the analysis results to generate an appropriate response to a user message.

[1500] The "display means" is a function that displays the generated response message on the user device.

[1501] A "voice synthesis engine" is a technology that converts text data into speech in the voice of a specified character and plays it back in a natural voice.

[1502] The "communication means" is a function that sends messages from users to a server and transmits responses generated by the server to user terminals in real time.

[1503] The "history management means" is a function that stores the history of interactions with characters and allows the user to refer to that history at any time.

[1504] This invention is a system that enables users to enjoy natural conversations with anime characters and historical figures. An example of this system is shown below.

[1505] System Configuration

[1506] This system consists of a server and a user terminal. The server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, and a speech synthesis engine. The user terminal includes a display means, a user interface, a communication means, and a history management means.

[1507] Server Processing

[1508] 1. Collection Method:

[1509] The server collects data such as anime dialogue and biographies of historical figures from websites and APIs, and stores it in a database, where dialogue data is organized by character.

[1510] 2. Pretreatment methods:

[1511] The server cleans the collected data, tokenizing and normalizing it, which removes noise from the text data and makes it parseable.

[1512] 3. Learning medium:

[1513] The preprocessed data is used to train a generative AI model, which then learns the character's speaking style and thought patterns, enabling it to generate natural-looking dialogue.

[1514] 4. Analysis method:

[1515] The server analyzes messages sent by users and understands their intent. For example, a message like "How was your day?" is recognized as a question for a specific character.

[1516] 5. Response Generation Method:

[1517] Based on the analysis results, an appropriate character generation AI model is used to generate a response to the user's message, for example, "I spent today watching movies."

[1518] 6. Speech synthesis engine:

[1519] The generated response is synthesized into a voice using the specified character's voice and played back as a natural voice.

[1520] User terminal processing

[1521] 1. Display and User Interface:

[1522] The user terminal provides a chat interface for interaction, where users can type and send messages.

[1523] 2. Means of communication:

[1524] A message entered by the user is transmitted to the server via the communication means, and a response generated by the server is transmitted to the user terminal via the communication means again.

[1525] 3. History Management Methods:

[1526] The device stores the history of interactions with the character, allowing the user to refer to past interactions at any time.

[1527] Hardware and software used

[1528] Smartphones, smart glasses, head-mounted displays: used as user devices.

[1529] Text analysis libraries (e.g. spaCy): Used to preprocess data.

[1530] Generative AI model (e.g. GPT): Used as a generative AI model.

[1531] A speech synthesis engine (e.g., Amazon Polly): Used for speech synthesis.

[1532] Specific examples

[1533] When a user interacts with a character named Sakata Gintoki, the user inputs and sends the message "How was your day?". An example of a prompt sentence is "When you ask Sakata Gintoki, "How was your day?", generate a response from his character model."

[1534] This allows the system to generate a response such as "I spent today watching movies," which can be displayed on the user's device and played back as audio.

[1535] Thus, the system of the present invention allows users to enjoy natural and interactive dialogue with anime characters and historical figures.

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

[1537] Step 1:

[1538] Collecting character data

[1539] The server collects data such as anime dialogue and biographies of historical figures from websites and APIs, and organizes this data by character and stores it in a database.

[1540] Input: Text data obtained from a website or API

[1541] Output: Raw data stored in a database

[1542] Specific operation: The server accesses a specific URL and retrieves the lines and information of each character. The retrieved data is then stored directly in the database.

[1543] Step 2:

[1544] Data Preprocessing

[1545] The server cleans the collected data, tokenizing and normalizing it, which removes noise from the text data and puts it into a format that can be analyzed.

[1546] Input: Raw data stored in a database

[1547] Output: Preprocessed, clean text data

[1548] What it does: The server uses a text analysis library (e.g. spaCy) to tokenize the text and remove unnecessary noise and profanity.

[1549] Step 3:

[1550] Training generative AI models

[1551] The server uses the preprocessed data to train a generative AI model (e.g., GPT), which learns the character's speaking style and thought patterns, enabling it to generate natural dialogue.

[1552] Input: Preprocessed text data

[1553] Output: A trained generative AI model

[1554] Specific operation: The server uses an AI learning framework (e.g., TensorFlow) to input the preprocessed data into an AI model to learn the character's characteristics.

[1555] Step 4:

[1556] Parsing user requests

[1557] The server analyzes messages sent by users and understands their intent. For example, a message like "How was your day?" is recognized as a question to a specific character.

[1558] Input: Message from user

[1559] Output: Analyzed intent and target character

[1560] Specific operation: The server uses natural language processing (NLP) algorithms to analyze the user message and identify the message's intent and target characters.

[1561] Step 5:

[1562] Generating a response

[1563] The server uses the analysis results to generate a response to the user's message using an appropriate character generation AI model, for example, "I spent today watching movies."

[1564] Input: Analysis results and generated AI model

[1565] Output: The generated text response

[1566] Specific operation: The server inputs a prompt sentence into the generative AI model and generates a corresponding response for each character.

[1567] Step 6:

[1568] Speech synthesis

[1569] The server synthesizes the generated response in the voice of the specified character and plays it back as a natural voice.

[1570] Input: Generated text response

[1571] Output: A synthesized response

[1572] What happens: The server uses a speech synthesis engine (e.g., Amazon Polly) to convert the generated text response into audio data.

[1573] Step 7:

[1574] Response display on user terminal

[1575] The user terminal displays the response received from the server on the user interface.

[1576] Input: Text and audio data from the server

[1577] Output: Display and audio playback in the chat interface

[1578] Specific behavior: Display the response text in the chat interface and play the synthesized voice from the audio speaker.

[1579] Step 8:

[1580] History and Reference

[1581] The user terminal stores a history of interactions with the character, allowing the user to refer to past interactions at any time.

[1582] Input: Response and user message data

[1583] Output: Saved interaction history

[1584] Specific behavior: Each time a conversation is completed, the message and response are saved in a database, and past conversations are displayed when the user opens the history screen.

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

[1586] The system of the present invention not only allows users to naturally interact with anime characters and historical figures, but also recognizes the user's emotions and generates responses based on those emotions. The following describes in detail each means and operation of the system.

[1587] Processing performed by the server

[1588] Obtaining character data

[1589] The server collects relevant data, such as anime dialogue and biographies of historical figures, from websites and APIs. The collected data is stored in a database. For example, it retrieves dialogue data related to a specific character and stores it in the database.

[1590] Data Preprocessing

[1591] The server cleans and formats the collected data. Specifically, it removes unnecessary data and noise, and performs tokenization and normalization of the text data. This makes the data easier to analyze. For example, it removes noise from dialogue data and formats it in a format suitable for analysis.

[1592] Training generative AI models

[1593] The server uses the preprocessed data to train a generative AI model, which then learns the character's unique speech patterns and thought patterns. For example, the AI ​​model learns what words a particular character uses in what situations, and then reproduces the character's characteristics.

[1594] Parsing user requests

[1595] The server receives the request message sent by the user and analyzes its contents. This analysis determines which character the request is directed to and the intent of the request. For example, if a user sends a message saying "How was your day?", the message is analyzed as a question for a specific character.

[1596] Emotion analysis

[1597] The server analyzes the emotion of a user message using an emotion engine. The emotion engine identifies emotions from the text content and provides the information to the analysis means. For example, if a user sends a message saying "I'm happy!", the emotion engine identifies "joy" as the emotion.

[1598] Generate and send a response

[1599] Based on the results of the emotion analysis, the server uses a generative AI model of the target character to generate an appropriate response to the user's message. The generated response is based on the character's characteristics and the user's emotions. The response is sent from the server to the user's device. For example, if a user sends a message saying, "I feel sad," the model of Sakata Gintoki will respond with, "I see, that must have been tough. But I'm sure something good will happen tomorrow!"

[1600] Processing performed by the device

[1601] Providing a user interface

[1602] The device displays a chat interface that allows the user to interact with the character. This interface includes a message input field and a send button. For example, a chat window is displayed on a smartphone application.

[1603] Accepting and sending user input

[1604] When a user inputs a message and presses the send button, the terminal sends the input message to the server. For example, a user inputs "How was your day today?" and presses the send button.

[1605] Response from the server

[1606] The device displays the response message received from the server in the chat interface. The response message is displayed in a visible form to the user. For example, a response such as "Today was busy, but it was fun!" may be displayed.

[1607] User actions

[1608] Character Selection

[1609] Users can select a character they want to chat with from a list on the platform, and a conversation will begin based on the selected character. For example, a user can select Sakata Gintoki from the list and start chatting.

[1610] Continue chatting

[1611] The user can continue the conversation by typing messages and periodically sending new messages to the character. The character will then respond and the conversation can continue. For example, the user can type "How are you doing lately?", and the character will respond with "I'm fine, how about you?"

[1612] The present invention, as described above, allows users to enjoy natural conversations with their favorite characters and historical figures. Furthermore, the quality of the conversation can be improved by recognizing the user's emotions and generating responses based on those emotions. Furthermore, the present invention can meet a variety of needs by providing a platform where users can create and sell their own unique characters.

[1613] The processing flow will be explained below.

[1614] Step 1:

[1615] Data collection (server)

[1616] The server collects relevant data, such as anime dialogue and biographies of historical figures, from websites and APIs. The collected data is stored in a database. For example, it retrieves dialogue data related to a specific character and stores it in the database.

[1617] Step 2:

[1618] Data preprocessing (server)

[1619] The server cleans and formats the collected data. Specifically, it removes unnecessary data and noise, and performs tokenization and normalization of the text data. This makes the data easier to analyze. For example, it removes noise from dialogue data and formats it in a format suitable for analysis.

[1620] Step 3:

[1621] Creating a dataset (server)

[1622] The server creates a training dataset based on the preprocessed data. It extracts data related to specific characters and formats it for training purposes. For example, it extracts only the lines of Sakata Gintoki and formats them as a training dataset.

[1623] Step 4:

[1624] Training generative AI models (server)

[1625] The server uses the created dataset to train a generative AI model. During this process, the AI ​​model learns the character's unique speaking and thinking patterns. For example, the AI ​​model learns what words a particular character uses in what situations, and reproduces the character's characteristics.

[1626] Step 5:

[1627] Receiving user requests (server)

[1628] The server receives messages from users, for example, messages that users type into a chat window are sent to the server.

[1629] Step 6:

[1630] Request analysis (server)

[1631] The server analyzes the received message and identifies the message content and the target character. Natural language processing technology is used for the analysis. For example, if a user sends a message saying, "How was your day?", the message is analyzed as a question for a specific character.

[1632] Step 7:

[1633] Sentiment analysis (server)

[1634] The server analyzes the emotion of a user message using an emotion engine. The emotion engine identifies emotions from the text content and provides the information to the analysis means. For example, if a user sends a message saying "I'm happy!", the emotion engine identifies "joy" as the emotion.

[1635] Step 8:

[1636] Response generation (server)

[1637] Based on the results of the emotion analysis, the server uses a generative AI model of the target character to generate an appropriate response to the user's message. The generated response is based on the character's characteristics and the user's emotions. For example, if a user sends a message saying, "I feel sad," the model of Sakata Gintoki will respond with, "I see, that must have been tough. But I'm sure something good will happen tomorrow!"

[1638] Step 9:

[1639] Response sending (server)

[1640] The server then sends the generated response to the user's device. The response message is sent in the format that will be displayed in the user's chat window. For example, in response to "How was your day?", "I had a great time today!" is sent to the device.

[1641] Step 10:

[1642] User interface display (terminal)

[1643] The device displays a chat interface that allows the user to interact with the character. This interface includes a message input field and a send button. For example, a chat window is displayed on a smartphone application.

[1644] Step 11:

[1645] Accepting user input (terminal)

[1646] When a user inputs a message and presses the send button, the terminal sends the input message to the server. For example, a user inputs "How was your day today?" and presses the send button.

[1647] Step 12:

[1648] Response display from server (terminal)

[1649] The device displays the response message received from the server in the chat interface. The response message is displayed in a visible form to the user. For example, in response to "How was your day?", "Today was busy, but fun!" is displayed.

[1650] Step 13:

[1651] Character Selection (User)

[1652] Users can select a character they want to chat with from a list on the platform, and a conversation will begin based on the selected character. For example, a user can select Sakata Gintoki from the list and start chatting.

[1653] Step 14:

[1654] Continue chat (user)

[1655] The user can continue the conversation by typing messages and periodically sending new messages to the character. The character will then respond and the conversation can continue. For example, the user can type "How are you doing lately?", and the character will respond with "I'm fine, how about you?"

[1656] The present invention, as described above, allows users to enjoy natural conversations with their favorite characters and historical figures. Furthermore, the quality of the conversation can be improved by recognizing the user's emotions and generating responses based on those emotions. Furthermore, the present invention can meet a variety of needs by providing a platform where users can create and sell their own unique characters.

[1657] Example 2

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

[1659] Existing chat systems have made it difficult for users to interact naturally with characters or historical figures. They also lacked the technology to properly recognize users' emotions and generate responses based on them. This limited the user experience and reduced the quality of the interaction.

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

[1661] In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a sentiment analysis means, a response generation means, and a display means, which allows a user to have natural conversations with characters or historical figures and receive responses based on the user's sentiments.

[1662] A "collection method" is a part of a system that automatically retrieves information from websites and data sources and stores it in a database.

[1663] "Preprocessing means" is the part of the system that cleans collected data and processes it through processes such as tokenization and normalization, making it suitable for analysis and model training.

[1664] The "learning means" is the part of the system that uses pre-processed data to train the generative AI model to acquire a character's unique speech patterns and thought patterns.

[1665] The "analysis means" is a part of the system that receives a request sent by a user, analyzes the content of the request, and understands the intent of the message and the person being interacted with.

[1666] The "emotion analysis means" is the part of the system that identifies emotions from users' messages and provides that information to the analysis means.

[1667] A "response generation means" is a part of the system that generates an appropriate response to a user message using a generative AI model based on the results of sentiment analysis.

[1668] The "display means" is a part of the system that provides an interface for interaction between the user and the character, and displays message input and responses from the server.

[1669] The system of the present invention not only allows users to naturally interact with anime characters and historical figures, but also recognizes the user's emotions and generates responses. The following hardware and software are used to implement this system.

[1670] 1. Server

[1671] The server includes a collection means for collecting information from websites and data sources, a pre-processing means for performing pre-processing such as cleaning and tokenizing the data, a learning means for training the generative AI model, an analysis means for analyzing user requests, a sentiment analysis means for performing sentiment analysis, and a response generation means for generating responses to the user.

[1672] Collection Method

[1673] The server uses a Python scraping tool (e.g., BeautifulSoup) to collect data about characters and historical figures from websites, which is then stored in an SQL database.

[1674] Pretreatment means

[1675] The server uses the Python NLTK library to perform data cleaning and text tokenization / normalization. The collected data is then tokenized and normalized to remove unnecessary noise and prepare it in a format suitable for analysis.

[1676] Learning tools

[1677] The server trains a generative AI model (e.g., GPT-3) using TensorFlow or PyTorch, which learns the character's unique speech patterns and language usage, acquiring the character's characteristics.

[1678] Analysis means

[1679] The server uses Natural Language Processing (NLP) technology to analyze the request message from the user. Specifically, it analyzes the message received as an HTTP request and identifies its intent and target.

[1680] Emotion analysis means

[1681] The server analyzes the emotion of the user message using an emotion recognition API (for example, Microsoft Azure's Text Analytics API). The result of the emotion analysis is identified as an emotion such as "joy" or "sadness."

[1682] Response Generation Method

[1683] The server uses a generative AI model to generate an appropriate response based on the results of emotion analysis. For example, if a user enters "I was sad today," the server generates a response such as "That was tough, but I'm sure good things will happen tomorrow!"

[1684] 2. Terminal

[1685] The terminal provides an interface for users to interact with characters, and has the following main functions:

[1686] Providing a user interface

[1687] The device uses a mobile application framework (e.g., React Native) to display a chat interface, which includes a message input field and a send button.

[1688] Accepting and sending user input

[1689] When a user enters a message and presses the send button, the device automatically sends the message to the server as an HTTP POST request, triggered by an event listener on the device.

[1690] Response from the server

[1691] The terminal displays the response message received from the server in the chat window. The response message is displayed in real time so that the user can immediately check it.

[1692] 3. Users

[1693] The user interacts with the character via the terminal.

[1694] Character Selection

[1695] Users select the character they want to interact with from a list on the platform, and then the interaction begins.

[1696] Enter and send a message

[1697] The user enters a message to continue the conversation and presses the send button, for example, "How was your day today?" This input is immediately sent to the server.

[1698] Prompt Sentence Examples

[1699] Prompt: "I felt sad."

[1700] Character: fictional character

[1701] Sample response: "I see, that was tough. But I'm sure tomorrow will be better!"

[1702] Based on these steps, users can enjoy natural and emotional interactions with characters and historical figures.

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

[1704] Step 1: Obtaining Character Data

[1705] The server collects data related to characters and historical figures from websites and APIs. A Python scraping tool (e.g., BeautifulSoup) is used as the collection method. A specific URL or API endpoint is specified as input, and dialogue or text data is obtained as output. The collected data is then stored in an SQL database.

[1706] Specifically, the server accesses the specified URL, analyzes the HTML structure, and extracts the required text data. When retrieving data from the API, it requests the data using the API key and parameters, and receives the response.

[1707] Step 2: Preprocessing the data

[1708] The server cleans and preprocesses the collected data. It uses the Python NLTK library as a preprocessing method, taking the collected text data as input and generating tokenized and normalized data as output.

[1709] Specifically, the server removes unnecessary noise and typos from the collected text data, tokenizes the text to break it down into words and phrases, and normalizes the word forms to make them uniform.

[1710] Step 3: Training the generative AI model

[1711] The server uses the preprocessed data to train a generative AI model, using TensorFlow or PyTorch as the learning medium. It provides the preprocessed dataset as input and obtains a trained generative AI model as output.

[1712] Specifically, the server uses the dataset to adjust the model's parameters and train it to learn the character's unique vocabulary and speaking style. This process is repeated, improving the model's accuracy based on a large amount of data.

[1713] Step 4: Receiving and parsing user requests

[1714] The device receives messages from users and sends them to the server. NLP technology is used as the analysis method. The request message from the user is received as input, and the intention of the message and the target character are identified as output.

[1715] Specifically, the device receives the user's message from the message input field and sends it to the server as an HTTP POST request. The server then analyzes the received message and understands its content.

[1716] Step 5: Sentiment Analysis

[1717] The server uses an emotion recognition API to analyze the emotion of the user message. As a means of emotion analysis, it uses Microsoft Azure's Text Analytics API. It receives the user message as input and generates identified emotion information as output.

[1718] Specifically, the server sends the user's text message to an emotion recognition API and identifies the emotion based on the response from the API. For example, the message "I'm happy!" is identified as "joy."

[1719] Step 6: Generate and send a response

[1720] The server uses the generative AI model to generate an appropriate response to the user message. As a response generator, it provides inputs including the results of preprocessing and sentiment analysis, and generates a response message as an output.

[1721] Specifically, the server operates a generative AI model based on the results of emotion analysis to generate an appropriate response. For example, if a user inputs "I was sad today," the system generates a response such as "That was tough, but I'm sure good things will happen tomorrow!" The generated response is then sent from the server to the user's device.

[1722] Step 7: User Interface Display

[1723] The device provides a chat interface for interaction between the user and the character. It uses a mobile application framework such as React Native as the display method. It receives response messages from the server as input and displays them in the chat window as output.

[1724] Specifically, the device receives messages from the server in real time and reflects them on the user interface, allowing the user to instantly see the character's response.

[1725] Step 8: Accepting and Sending User Input

[1726] When the user types a message and presses the send button, the device sends the message to the server. It takes a text message from the user as input and sends it to the server as output.

[1727] Specifically, the user enters the content of the conversation in the message input field and presses the send button. This input information is sent to the server as an HTTP POST request by the terminal.

[1728] Step 9: View the response from the server

[1729] The terminal displays the response message received from the server in the chat interface. It receives the response message from the server as input and displays it in a form that is visible to the user as output.

[1730] Specifically, the terminal reflects the response from the server in the chat window in real time, allowing the user to check it immediately.

[1731] (Application example 2)

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

[1733] Conventional virtual stores have the problem that users cannot receive appropriate support through dialogue when selecting products, which prevents them from fully increasing their purchasing motivation and satisfaction. In addition, they lack a mechanism to provide a more personalized purchasing experience by recognizing users' emotions and generating responses based on them.

[1734] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, an emotion analysis means, a virtual store means for supporting the user's purchasing behavior through dialogue, and a display means. This enables the user to receive a personalized response based on emotion when selecting a product through natural dialogue with an anime character.

[1735] "Collection means" refers to the function for obtaining data from websites and APIs and accumulating the necessary information.

[1736] "Preprocessing means" is a function that cleans up collected data and prepares it in a format suitable for analysis and learning.

[1737] "Learning tools" are functions for training generative AI models based on collected and preprocessed data.

[1738] The "analysis means" is a function for interpreting request messages and data sent by users and understanding their intent and content.

[1739] The "response generation means" is a function that generates an appropriate response based on the results of emotion analysis, and realizes a dialogue based on the character's characteristics and the user's emotions.

[1740] The "emotion analysis means" is a function for identifying emotions from a user's message and using that information for analysis.

[1741] The "virtual store means for supporting user purchasing behavior through dialogue" is a function that provides a virtual store where users can select and purchase products through dialogue with characters.

[1742] The "display means" is a function for providing a user interface and visually displaying message inputs and responses from the server.

[1743] The present invention provides a system for supporting the process of a user selecting and purchasing a product in a virtual store through interaction with an animated character. The system includes a collection means, a preprocessing means, a learning means, an analysis means, a response generation means, a sentiment analysis means, a virtual store means for supporting the user's purchasing behavior through interaction, and a display means.

[1744] Processing performed by the server

[1745] Collection Method

[1746] The server first collects the lines of the anime and related data from websites and APIs, such as lines related to a specific character or product information, and stores them in a database.

[1747] Pretreatment means

[1748] The collected data is cleaned, denoised, and formatted, for example by removing unnecessary information from dialogue data and tokenizing text data to convert it into a format suitable for analysis.

[1749] Learning tools

[1750] The preprocessed data is used to train a generative AI model, which then learns the character's unique speech and thought patterns. For example, the model learns what words a particular character uses in what situations, and then reproduces the character's characteristics.

[1751] Analysis means

[1752] It receives request messages sent by users and analyzes their contents. For example, if a user sends a message saying "I'm looking for a new manga," it analyzes the message as a question to the character.

[1753] Emotion analysis means

[1754] The emotion engine is used to analyze the emotion of a user message. For example, if a user sends a message saying "I'm so excited!", the emotion engine will identify "excited" as the emotion.

[1755] Response Generation Method

[1756] Based on the results of the sentiment analysis, a generative AI model of the target character is used to generate an appropriate response to the user's message. For example, if a user says, "I'm looking for a new manga," the character will respond with, "Here are some recommended titles," and provide a list of related products.

[1757] Processing performed by the device

[1758] Display means

[1759] A chat interface is provided for users to interact with characters. This interface includes a message input field and a send button. For example, a chat window is displayed on a smartphone application.

[1760] Accepting and sending user input

[1761] When a user inputs a message and presses the send button, the message is sent to the server. For example, a user inputs "I'm looking for new manga" and presses the send button.

[1762] Response from the server

[1763] The response message received from the server is displayed in the chat interface. For example, a character may respond with "This is the recommended title."

[1764] Specific examples

[1765] Users can access a virtual store and enjoy interactive shopping. When a user says to a character, "I'm looking for a new manga," the character will respond with, "Here are some recommended titles," and suggest a list of related products. This process generates a response based on the user's emotions, allowing the user to enjoy a highly personalized shopping experience.

[1766] An example of a prompt is

[1767] User types: "I'm looking for new manga."

[1768] The character responds: "Here's a recommended title."

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

[1770] Step 1:

[1771] The server uses collection tools to obtain dialogue data and product information related to anime characters from websites and APIs. Specifically, it obtains data from APIs and stores it in a database. The input is a URL or API endpoint, and the output is the data that is stored in the database.

[1772] Step 2:

[1773] The server uses preprocessing tools to clean up the collected data and prepare it in a format suitable for analysis and learning. Specifically, it removes unnecessary information and tokenizes the text data. The input is the collected data, and the output is the cleaned text data.

[1774] Step 3:

[1775] The server uses a learning mechanism to train a generative AI model using the preprocessed data. Specifically, it uses the data as a training dataset to generate a model that learns the character's unique speech and thought patterns. The input is the preprocessed data, and the output is a trained generative AI model.

[1776] Step 4:

[1777] The device provides a user interface that allows users to initiate a conversation. Specifically, the chat interface displays a message input field and a send button. The input is the user interface design, and the output is the on-screen chat window.

[1778] Step 5:

[1779] When a user enters a message and presses the send button, the device sends the message to the server. Specifically, the device sends the user's input data as an API request. The input is the text message entered by the user, and the output is the request sent to the server.

[1780] Step 6:

[1781] The server uses an analysis method to analyze the request message from the user. Specifically, it performs natural language processing to interpret the message content and understand its intent. The input is the user's message, and the output is the result of analyzing the message content.

[1782] Step 7:

[1783] The server uses an emotion analysis means to analyze the emotion of the user message. Specifically, it uses an emotion engine to extract emotion data from the message. The input is the analyzed user message, and the output is the emotion data.

[1784] Step 8:

[1785] The server uses a response generation means to generate an appropriate response using a generative AI model based on the results of emotion analysis. Specifically, a response based on the user's emotion and the message content is generated from the generative model. The inputs are emotion data and the analyzed message, and the output is a generated response message.

[1786] Step 9:

[1787] The server generates a response message and sends it to the terminal. The response message is the input, and the transmission to the terminal is the output.

[1788] Step 10:

[1789] The terminal uses a display means to display the received response message in the chat interface. Specifically, the response message is displayed in a form that is visible to the user. The input is the message received from the server, and the output is the response displayed in the chat window.

[1790] Step 11:

[1791] The user can review the displayed response and continue the conversation as needed. For example, if the user types "I'm looking for a new manga" and the character responds with "Here are some recommended titles," the user can ask more specific questions or make selections.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[1813] The following is further disclosed regarding the above embodiment.

[1814] (Claim 1)

[1815] Collection means;

[1816] A pre-processing means;

[1817] Learning tools and

[1818] Analysis means;

[1819] a response generating means;

[1820] A system including a display means.

[1821] (Claim 2)

[1822] said display means providing a user interface;

[1823] 10. The system of claim 1, further comprising means for receiving and transmitting user input to the preprocessing means.

[1824] (Claim 3)

[1825] The system of claim 1, further comprising a collection means and a pre-processing means for collecting and cleaning data from websites and APIs.

[1826] (Claim 4)

[1827] 2. The system according to claim 1, further comprising a learning means for inputting character data into a generative AI model and causing the model to learn the character's unique speaking style and thought patterns.

[1828] (Claim 5)

[1829] 2. The system according to claim 1, further comprising the analyzing means for receiving and analyzing a user request to identify a target character.

[1830] (Claim 6)

[1831] 2. The system of claim 1, further comprising the response generation means for generating a response using an AI model of the target character and transmitting the response to the user's terminal.

[1832] "Example 1"

[1833] (Claim 1)

[1834] Collection means;

[1835] A pre-processing means;

[1836] Learning tools and

[1837] Analysis means;

[1838] a response generating means;

[1839] A system including a display means,

[1840] said collection means for collecting and cleaning natural language data from websites and APIs;

[1841] The pre-processing means tokenizes and normalizes the collected data for pre-processing;

[1842] said learning means for training a generative artificial intelligence model using preprocessed data;

[1843] said analysis means for receiving a request message from a user and analyzing content related to the character;

[1844] the response generation means for generating an appropriate response using a generative artificial intelligence model based on the analysis results;

[1845] The system includes the display means for transmitting the generated response to a user terminal for display.

[1846] (Claim 2)

[1847] said display means providing a user interface;

[1848] 10. The system of claim 1, further comprising means for receiving and transmitting user input to the preprocessing means.

[1849] (Claim 3)

[1850] said pre-processing means for cleaning, tokenizing and normalizing the collected linguistic data;

[1851] 10. The system of claim 1, further comprising the learning means utilizing preprocessed data to train a generative artificial intelligence model.

[1852] "Application Example 1"

[1853] (Claim 1)

[1854] Collection means;

[1855] A pre-processing means;

[1856] Learning tools and

[1857] Analysis means;

[1858] a response generating means;

[1859] A display means;

[1860] means for playing a response message on the terminal using a speech synthesis engine;

[1861] communication means for processing user messages in real time;

[1862] A system including a history management means for managing interactions with characters.

[1863] (Claim 2)

[1864] said display means providing a user interface;

[1865] 10. The system of claim 1, further comprising means for receiving and transmitting user input to the preprocessing means.

[1866] (Claim 3)

[1867] The system of claim 1, further comprising a collection means and a pre-processing means for collecting and cleaning data from websites and APIs.

[1868] "Example 2: Combining Emotion Engines"

[1869] (Claim 1)

[1870] Collection means;

[1871] A pre-processing means;

[1872] Learning tools and

[1873] Analysis means;

[1874] A sentiment analysis means;

[1875] a response generating means;

[1876] A system including a display means.

[1877] (Claim 2)

[1878] said display means providing a user interface;

[1879] 10. The system of claim 1, further comprising means for receiving and transmitting user input to the preprocessing means.

[1880] (Claim 3)

[1881] 10. The system of claim 1, further comprising a collection means and a pre-processing means for collecting and cleaning information from websites and data sources.

[1882] "Application example 2 when combining emotion engines"

[1883] (Claim 1)

[1884] Collection means;

[1885] A pre-processing means;

[1886] Learning tools and

[1887] Analysis means;

[1888] a response generating means;

[1889] A sentiment analysis means;

[1890] A virtual store means for supporting a user's purchasing behavior through dialogue;

[1891] A system including a display means.

[1892] (Claim 2)

[1893] said display means providing a user interface;

[1894] 10. The system of claim 1, further comprising means for receiving and transmitting user input to the preprocessing means.

[1895] (Claim 3)

[1896] The system of claim 1, further comprising a collection means and a pre-processing means for collecting and cleaning data from websites and APIs. [Explanation of symbols]

[1897] 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. Collection means; A pre-processing means; Learning tools and Analysis means; a response generating means; A system including a display means.

2. said display means providing a user interface; 2. The system of claim 1, further comprising means for receiving and transmitting user input to the preprocessing means.

3. The system of claim 1 , further comprising a collection means and a pre-processing means for collecting and cleaning data from websites and APIs.

4. The system according to claim 1, further comprising a learning means for inputting character data into a generative AI model and causing the model to learn the character's unique speaking style and thought patterns.

5. 2. The system of claim 1, further comprising the analyzing means for receiving and analyzing a user request to identify a target character.

6. The system of claim 1 , further comprising a response generation means for generating a response using an AI model of the target character and transmitting the response to the user's terminal.

Images