System

Abstract

A system is provided.SOLUTION: A system comprising: server means having a database for generating a random topic; terminal means for transmitting a topic generation request to the server means; and means for transmitting a topic randomly selected by the server means to the terminal means and displaying the received topic.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] In modern workplaces and social settings, promoting smooth communication between participants is extremely important. However, starting a conversation can often be difficult, especially when meeting people for the first time or when talking with people from different departments. Preparing appropriate topics for icebreakers before meetings or as brain teasers during morning meetings also takes time and effort. A method is needed to improve this situation and enable participants to start conversations naturally. [Means for solving the problem]

[0005] To solve this problem, the present invention provides a system for generating random topics. This system includes a server means having a database for generating random topics, a terminal means for sending a topic generation request to the server means, and a means for transmitting a topic randomly selected by the server means to the terminal means and displaying the received topic. This allows participants to easily get started on a conversation and promotes natural communication. Furthermore, the topics displayed by the terminal means have an interface that can be viewed by the user and used as a conversation starter, which helps to stimulate conversation.

[0006] The "server means" is a server including a database, and has the function of generating random topics and transmitting the selected topics to the terminal means.

[0007] The "terminal means" is a device operated by a user, and has the function of sending a topic generation request to the server means and displaying the received topic.

[0008] A "topic generation request" is a request sent from a terminal means to a server means, and requests the provision of a random topic.

[0009] A "database" is a storage system that stores multiple topic information items and is accessed by a server means.

[0010] A "randomly selected topic" is one topic randomly selected from multiple topics stored in the database.

[0011] "Sending to terminal means" refers to the transmission of a topic randomly selected by the server means to the terminal means via the network.

[0012] The "display means" has a function for the terminal means to visually show the user the topic received from the server means. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0021] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0034] The system of the present invention generates and displays random topics for users to use as conversation starters. The system has the roles of a server, a terminal, and a user, which are described below.

[0035] Server Operation

[0036] The server maintains a topic database, which stores multiple topics. When the server starts, it first loads this topic database into memory. When it receives a topic generation request from a user, the server randomly selects one topic from the database. The selected topic is sent to the terminal in JSON format.

[0037] As a concrete example, suppose the server loads a database with topics such as "What language have you written recently?" and "What is your favorite food?", and then randomly selects "What is your favorite food?" This selected topic is sent to the device.

[0038] Device behavior

[0039] The terminal is a device operated by the user. When the user launches the app and clicks a specific button, the terminal sends a topic creation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user.

[0040] Specifically, when a user clicks the "Generate a new topic" button, the device sends a request to the server and receives the topic "What is your favorite food?" from the server. The device displays this on the screen so that the user can check it.

[0041] User operations

[0042] Users simply launch the application on their device and click a button to generate a new topic, which they will receive as a conversation starter, allowing them to easily start a conversation and communicate naturally.

[0043] For example, if a user launches the app before a morning meeting and clicks the "Generate a new topic" button, the device sends a request to the server, which then displays a randomly selected topic, such as "What's your favorite food?", which the user can use to start a conversation with their colleagues.

[0044] In this way, the system of the present invention provides users with random topics through communication between the server and the terminal, helping them to start conversations naturally. The server's topic database, random selection algorithm, and terminal interface work together to create a system that is highly convenient for users.

[0045] The processing flow will be explained below.

[0046] Server-side processing steps

[0047] Step 1:

[0048] The server starts and loads the topic database, which contains multiple topics. For example, the database might contain questions like "What language have you written in recently?" or "What is your favorite food?"

[0049] Step 2:

[0050] The server waits for an HTTP GET request to a specific endpoint (e.g., / get_random_topic).

[0051] Step 3:

[0052] The server receives a topic creation request from a terminal. This request is for the creation of a topic.

[0053] Step 4:

[0054] The server randomly selects a topic from the topic database using the Python function random.choice() .

[0055] Step 5:

[0056] The server sends the selected topic in JSON format to the terminal, and the response includes the selected topic.

[0057] Terminal processing steps

[0058] Step 1:

[0059] The terminal will start up and display a user interface where the user can see a "Create a new topic" button.

[0060] Step 2:

[0061] The user clicks the "Create a new topic" button. This action causes the device to send a topic creation request to the server.

[0062] Step 3:

[0063] The server receives the request sent by the terminal and receives a response containing a randomly selected topic from the server.

[0064] Step 4:

[0065] The device parses the response from the server and extracts the topic from the JSON data included in the response.

[0066] Step 5:

[0067] The terminal displays the extracted topics on the user interface, allowing the user to check the displayed topics.

[0068] User operation steps

[0069] Step 1:

[0070] The user launches the app, which prepares the device for topic generation.

[0071] Step 2:

[0072] The user clicks the "Create a new topic" button, which causes the device to send a topic creation request to the server.

[0073] Step 3:

[0074] The user checks the topic displayed on the device. For example, the topic "What is your favorite food?" is displayed.

[0075] Step 4:

[0076] Users can start conversations based on the displayed topics, which promotes natural communication.

[0077] Example 1

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

[0079] Conventional methods for starting conversations require users to come up with topics themselves, which is time-consuming and inefficient. Furthermore, systems that use fixed topics lack freshness and make it difficult to promote natural communication. Therefore, a system that allows users to quickly and easily obtain new conversation starters was needed.

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

[0081] In this invention, the server includes a means for maintaining a topic database and loading it into memory when the server starts up, a means including an algorithm for receiving a topic generation request from a user and randomly selecting one topic from the database, and a means for converting the selected topic into JSON format and sending it to a terminal, thereby enabling users to quickly and easily obtain new conversation starters.

[0082] A "topic database" is a database for storing multiple topics that serve as conversation starters.

[0083] "Loading into memory" means reading the contents of the database into the main memory device for temporary storage at startup.

[0084] A "topic creation request" is an action in which a user requests the server to create a new topic via a terminal.

[0085] A "random selection algorithm" is a computational method for randomly selecting one of the topics in a topic database.

[0086] "JSON format" is an abbreviation for JavaScript Object Notation, and is a data format that structures data in text format and makes it exchangeable.

[0087] A "terminal" is an electronic device such as a computer or smartphone that is operated by a user.

[0088] A "response" is response data sent from a server to a terminal.

[0089] A "user" is a person who operates the system to send topic creation requests and review the created topics.

[0090] An "interface" is a screen or operating means for displaying topics to a user on a terminal.

[0091] A specific embodiment of the system of the present invention, which generates and displays random topics for users to use as conversation starters, is described below.

[0092] Server Operation

[0093] The server maintains a topic database. When the server starts, it first loads this topic database into memory. This database stores multiple topics that can serve as conversation starters. When the server receives a topic generation request from a user, it randomly selects one topic from the database. The selected topic is converted into JSON format and sent to the terminal. Server processing can be achieved, for example, by using Python's random.choice function.

[0094] Device behavior

[0095] The terminal is a device operated by the user. When the user launches a dedicated application and clicks the "Create a new topic" button, the terminal sends an HTTP request to the server. This request is a request to create a topic. When the terminal receives a response from the server, it parses the received JSON data and extracts the topic text. The extracted text is displayed to the user. The display interface of the terminal is realized using, for example, HTML and JavaScript.

[0096] User operations

[0097] Users simply launch the application on their device and click a button to generate a new topic, which they will receive as a conversation starter, allowing them to easily start a conversation and communicate naturally.

[0098] Examples and behavior

[0099] For example, the topic database contains topics such as "What language have you written recently?" and "What is your favorite food?" When a user clicks the "Generate a new topic" button, the device sends a request to the server, which randomly selects the topic "What is your favorite food?" and sends it to the device. The device then displays it on the screen so that the user can check it.

[0100] Examples of prompt statements

[0101] Examples of prompts for a generative AI model might include:

[0102] "When a user clicks the 'Generate a new topic' button on their device, how do I have the server randomly select a topic and send it to the device?"

[0103] "Please tell me how the server selects a random topic and sends it to the device."

[0104] In this way, by having the roles of the server, terminal, and user work in cooperation with each other, the user can quickly and easily get a conversation start. The present invention contributes to smoother conversation and promotion of communication.

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

[0106] Step 1: Start the server

[0107] When the server starts, it loads the topic database into memory. The server reads the topic database file from local or remote storage and stores it in memory (e.g., RAM), allowing the server to quickly access all the topics in the topic database.

[0108] Input: topic database file

[0109] Output: Topic database loaded in memory

[0110] Step 2: User clicks a button

[0111] The user launches a dedicated application and clicks the "Create a new topic" button, which sends a creation request from the device to the server. The request is usually executed as an HTTP POST request.

[0112] Input: User clicks a button

[0113] Output: HTTP POST request to the server

[0114] Step 3: Receiving the request on the server

[0115] The server receives a request to create a topic from a user. The server parses the HTTP request and verifies that the request is for creating a topic.

[0116] Input: HTTP POST request

[0117] Output: Recognition of topic creation request

[0118] Step 4: Random Topic Selection

[0119] The server retrieves all topics in the topic database and uses a random algorithm (e.g., Python's random.choice function) to select one topic, which is later converted to JSON format.

[0120] Input: Topic database

[0121] Output: Randomly chosen topics

[0122] Step 5: Converting Topics to JSON Format

[0123] The server converts the selected topics into JSON format, for example using the Python json.dumps function.

[0124] Input: A randomly selected topic

[0125] Output: Topic data in JSON format

[0126] Step 6: Submit to Topic

[0127] The server converts the topic into JSON format and sends it to the terminal as an HTTP response, which also includes an HTTP status code and header information.

[0128] Input: JSON formatted topic data

[0129] Output: HTTP response to the device

[0130] Step 7: Receiving and Parsing the Response

[0131] The device receives the HTTP response from the server and parses the response using the JavaScript JSON.parse function or similar.

[0132] Input: HTTP response

[0133] Output: Parsed topic data

[0134] Step 8: Viewing Topics

[0135] The device displays the parsed topic data to the user, using the device's interface (e.g., HTML elements or UI components of a mobile app).

[0136] Input: Parsed topic data

[0137] Output: A user-visible topic display

[0138] In this way, random topics are provided to users and can be used as conversation starters.

[0139] (Application example 1)

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

[0141] Conventional systems have difficulty not only generating and displaying topics that allow users to naturally start conversations, but also providing appropriate topics according to specific contexts and purposes. Furthermore, while effective customer support is required in virtual stores, existing methods are sometimes unable to adequately address this need. This has led to a demand for improved user experience and customer satisfaction.

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

[0143] In this invention, the server includes means for having a database for generating random topics, terminal means for sending topic generation requests, means for sending randomly selected topics to the terminal means and displaying the received topics, and means for using a generative AI model to generate topics that can be used as conversation starters, thereby enabling users to provide appropriate topics for specific contexts in customer support within a virtual store, rather than simply receiving random topics.

[0144] "Server means" refers to a device that has a database for generating random topics, receives a topic generation request, and has the function of sending a randomly selected topic to a terminal means, or software that implements that function.

[0145] The "terminal means" is a device that is operated by a user to send a topic generation request to the server means, and receives and displays the topic sent from the server, or software that implements the function thereof.

[0146] A "generative AI model" is an artificial intelligence algorithm or system that generates topics that can be used as conversation starters in a given context.

[0147] A "prompt sentence" is text data that is input into a generative AI model to generate an appropriate topic.

[0148] A "topic database" is a database that stores multiple topics and is used by the server means.

[0149] The following describes in detail the mode for carrying out the present invention. The system of the present invention supports users in starting conversations naturally by generating and displaying random topics. Specific embodiments will be described below.

[0150] Server Operation

[0151] The server maintains a topic database, which stores a large number of topics. When the server starts up, it first loads this topic database into memory. When it receives a topic generation request from a user, the server randomly selects a topic from the database. At this time, it uses a generative AI model to generate a prompt sentence to generate a topic appropriate for the specific context and purpose. The selected topic is sent to the terminal in JSON format.

[0152] For example, the server loads a database with topics such as "What is your favorite product these days?" and "Which product are you interested in?", then randomly selects "Which product are you interested in?", and this selected topic is sent to the device.

[0153] Device behavior

[0154] The terminal is a device operated by the user. When the user launches an application and clicks a specific button, the terminal sends a topic creation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user.

[0155] Specifically, when a user clicks the "Generate a new topic" button, the device sends a request to the server and receives the topic "Which product are you interested in?" from the server. The device displays this on the screen so that the user can check it.

[0156] User operations

[0157] Users simply launch the application on their device and click a button to create a new topic, which they will then receive as a conversation starter, allowing them to easily start a conversation and communicate naturally.

[0158] For example, consider a case where a user visits a virtual store and uses a customer support app. When the user clicks the "Generate a new topic" button, the device sends a request to the server, and the server randomly selects a topic, such as "Which product are you interested in?". The user can then start a conversation with the virtual assistant based on this topic.

[0159] Hardware and software used

[0160] Server: A powerful computer or cloud instance

[0161] Devices: smartphones, tablets, head-mounted displays

[0162] Software: Flask (a Python web framework), generative AI models (e.g., GPT-3)

[0163] Examples of prompts include:

[0164] "Randomly generate topics to start a conversation with your customers. For example: What's your favorite product these days?"

[0165] By combining these elements, the system of the present invention can provide users with highly convenient conversation starters and improve the quality of customer support in virtual stores.

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

[0167] Step 1:

[0168] A user starts the application and clicks the "Create a new topic" button. This action causes the device to send a topic creation request to the server. The input is the user's button click, and the output is an HTTP request that sends a topic creation request to the server.

[0169] Step 2:

[0170] When the server receives a topic generation request, it loads the topic database into memory. The input is the topic generation request, and the output is the loading of the topic database. The server internally generates a prompt using a generative AI model, and selects a topic based on this prompt.

[0171] Step 3:

[0172] The server uses a generative AI model to randomly generate topics from a topic database. Specifically, it inputs a prompt sentence into the generative AI model and obtains an appropriate topic as the output. The input is the prompt sentence and the topic database, and the output is a randomly selected topic.

[0173] Step 4:

[0174] The server converts the selected topic into JSON format and sends it to the terminal. The input is a randomly selected topic, and the output is JSON format data. The server returns this JSON data to the terminal as a response using the HTTP protocol.

[0175] Step 5:

[0176] The terminal receives a JSON-formatted response from the server and parses the data to extract the topic. The input is the received JSON data, and the output is the parsed topic. Specifically, the terminal parses the data using a JSON parser.

[0177] Step 6:

[0178] The terminal displays the extracted topics on the user interface. The input is the analyzed topic, and the output is the topic displayed on the user interface. The user can check this and use it as a conversation starter. Specifically, the topic is displayed in text format on the display.

[0179] This series of processing steps allows users to easily find suitable topics to start a conversation, enabling effective customer support, especially in scenarios such as virtual stores.

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

[0181] The system of the present invention generates and displays random topics for users to use as conversation starters, and also combines an emotion engine that recognizes the user's emotions. This system has the roles of a server, a terminal, an emotion engine, and a user, which are described below.

[0182] Server Operation

[0183] The server maintains a topic database, which stores multiple topics. When the server starts up, it first loads this topic database into memory. When it receives a topic generation request from a user, the server randomly selects one topic from the database. The selected topic is sent to the device in JSON format. It can also receive emotion data from the emotion engine and adjust the selected topic.

[0184] For example, the server loads a database with topics such as "What language have you written recently?" and "What is your favorite food?", and then randomly selects "What is your favorite food?" If the emotion engine detects that the user is excited, the server will prioritize selecting a more relaxed topic. This selected topic is then sent to the device.

[0185] Device behavior

[0186] The terminal is a device operated by the user. When the user launches the app and clicks a specific button, the terminal sends a topic generation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user. In addition, the terminal communicates with the emotion engine and sends the user's emotion data to the server.

[0187] Specifically, when a user clicks the "Generate a new topic" button, the device sends a request to the server and receives the topic "What is your favorite food?" from the server. The device displays this on the screen so that the user can confirm it. At the same time, emotion data from the emotion engine is sent to the server.

[0188] Emotion Engine Operation

[0189] The emotion engine recognizes emotions by analyzing the user's voice, facial expressions, or input data. Emotion data is acquired and analyzed in real time. This data is sent to the server via the device and used as a reference for further topic selection.

[0190] For example, if a user is smiling, the emotion engine will interpret this as a "positive emotion" and send it to the server, which can then prioritize more lively topics.

[0191] User operations

[0192] Users simply launch the application on their device and click the button to generate a new topic, which they receive as a conversation starter. This allows users to easily start a conversation and promote natural communication. Additionally, the emotion engine evaluates the user's emotional state in real time and provides the most appropriate topic based on the results.

[0193] For example, if a user starts the app before a morning meeting and clicks the "Generate a new topic" button, the device sends a request to the server, which then displays a topic that matches the user's emotion, such as "What is your favorite food?". The user can then start a conversation with their colleagues based on this topic.

[0194] In this way, the system of the present invention supports users in starting a conversation naturally by having the server, terminal, and emotion engine work together to provide random and appropriate topics to the user.

[0195] The processing flow will be explained below.

[0196] Server-side processing steps

[0197] Step 1:

[0198] The server starts and loads the topic database, which contains multiple topics, such as "What language have you written in recently?" or "What is your favorite food?"

[0199] Step 2:

[0200] The server waits for an HTTP GET request to a specific endpoint (e.g., / get_random_topic).

[0201] Step 3:

[0202] The server receives a topic creation request from a terminal. This request is for the creation of a topic.

[0203] Step 4:

[0204] The server receives the user's emotional data from the emotion engine, the emotional data including the user's current emotional state.

[0205] Step 5:

[0206] The server randomly selects a topic from the topic database using the Python function random.choice() .

[0207] Step 6:

[0208] The server adjusts the randomly selected topics by taking into account emotional data, for example, prioritizing relaxing topics if the user is feeling stressed.

[0209] Step 7:

[0210] The server sends the selected topic in JSON format to the terminal, and the response includes the selected topic.

[0211] Terminal processing steps

[0212] Step 1:

[0213] The terminal will start up and display a user interface where the user can see a "Create a new topic" button.

[0214] Step 2:

[0215] The user clicks the "Create a new topic" button. This action causes the device to send a topic creation request to the server.

[0216] Step 3:

[0217] The terminal collects the user's emotional data through an emotion engine, which includes the user's voice, facial expression, or input data.

[0218] Step 4:

[0219] The terminal transmits this emotion data to the server.

[0220] Step 5:

[0221] The terminal receives a response from the server that includes the topic.

[0222] Step 6:

[0223] The terminal analyzes the response received and extracts the topic.

[0224] Step 7:

[0225] The terminal displays the extracted topics on the user interface, allowing the user to check the displayed topics.

[0226] Emotion Engine Processing Steps

[0227] Step 1:

[0228] The emotion engine collects the user's voice, facial expressions, or input data.

[0229] Step 2:

[0230] The emotion engine analyzes the collected data and recognizes the user's emotional state.

[0231] Step 3:

[0232] The emotion data recognized by the emotion engine is sent to the server via the terminal.

[0233] User operation steps

[0234] Step 1:

[0235] The user launches the app, which prepares the device for topic generation.

[0236] Step 2:

[0237] The user clicks the "Create a new topic" button, which causes the device to send a topic creation request to the server.

[0238] Step 3:

[0239] The user checks the topic displayed on the device. For example, the topic "What is your favorite food?" is displayed.

[0240] Step 4:

[0241] Users can start conversations based on the displayed topics, which promotes natural communication.

[0242] Example 2

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

[0244] Conventional conversation starter systems provide random topics without considering the user's emotional state, making it difficult to provide a topic appropriate to the user's current emotions and situation. Furthermore, if the randomly selected topic does not match the user's preferences or emotional state, the conversation may start unnaturally. This can lead to a poor communication experience for the user.

[0245] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a processing device having data storage for generating random topics, a display device that sends a topic generation request to the processing device, a device that sends the topic randomly selected by the processing device to the display device and displays the received topic, a device that acquires emotional data from the display device and sends it to the processing device, and a device that adjusts the topic based on the emotional data from the processing device. This makes it possible to start a more natural and effective conversation by providing a topic that suits the user's emotional state.

[0246] A "processing device" is an electronic device capable of manipulating data and performing a particular function or service.

[0247] A "display device" is an electronic device that provides an interface for a user to visually confirm information.

[0248] "Data storage" is a storage device for storing information and data for long periods of time.

[0249] A "topic creation request" is an operation or message that a user sends to the server requesting the creation of a new topic.

[0250] "Random selection" is a method of selecting randomly without following any particular rule or order.

[0251] "Emotion data" is information that indicates the user's current emotional state, and is extracted from voice, facial expressions, and text data.

[0252] A "tuning device" is a device that has the ability to change or optimize the content of a selected topic based on acquired data.

[0253] This invention provides a system that generates random topics to prompt users to start a conversation and displays them to them. Furthermore, it supports more natural and effective communication by assessing the user's emotional state in real time and providing optimal topics based on that information.

[0254] Server configuration and operation

[0255] The server maintains a topic database, which stores various conversation topics. When the server starts up, the topic database is loaded into memory. When the server receives a topic generation request from a user, it randomly selects one topic from the database. This selected topic is sent to the device in JSON format. It also receives emotion data from the emotion engine and adjusts the topic selection based on that data.

[0256] For example, if the server stores topics such as "What did you do on your recent holiday?" and "What is your favorite food?" in a database, and a user sends a request, the server randomly selects the topic "What is your favorite food?" If the emotion engine evaluates the user's emotional state as "Relaxed," the server can prioritize topics such as "What did you do on your recent holiday?"

[0257] Terminal configuration and operation

[0258] The terminal is a device operated by the user, on which the user launches the application. When the user clicks the "Create a new topic" button, the terminal sends a topic creation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user. Furthermore, the terminal communicates with the emotion engine and sends the user's emotion data to the server.

[0259] For example, a user clicks the "Generate a new topic" button and receives the topic "What is your favorite food?" from the server. This topic will be displayed on the device screen, and the user can see it and start a conversation. At the same time, the device will collect the user's emotion data from the emotion engine and send it to the server in real time.

[0260] Emotion engine configuration and operation

[0261] The emotion engine analyzes the user's voice, facial expressions, and text to evaluate the user's emotional state in real time. This emotional data is sent to the server via the device and used as reference information for the server to select topics.

[0262] For example, if a user is smiling while looking at the app, the emotion engine will interpret this as a "positive emotion" and send that data to the server, which can then choose lively topics appropriate for the user.

[0263] Examples and prompts

[0264] As a concrete example, suppose a user launches the app during their morning commute and clicks the "Generate a new topic" button. The device sends a request to the server, which returns the topic "What is your favorite travel destination?" This information is displayed on the device, allowing the user to start a conversation with people around them.

[0265] An example of a prompt is:

[0266] "If the user is excited, choose a topic that will generate a relaxed buzz."

[0267] "Choose a conversation topic that's appropriate for when the user is sad."

[0268] Examples include:

[0269] In this way, the system's server, terminal, and emotion engine work together to provide users with appropriate conversation topics and support natural communication.

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

[0271] Step 1:

[0272] When the server starts up, it loads the topic database into memory. Specifically, it reads multiple conversation topics stored in the topic database into the server's memory. At this point, the database contains topics such as "What is your favorite food?" and "What did you do on your last holiday?" The input is the topic database, and the output is the topic list loaded into memory. This allows the server to be ready to quickly select a topic at any time.

[0273] Step 2:

[0274] A user launches the app on their device and clicks the "Create a new topic" button. This causes the device to send a topic creation request to the server. The input is the user's click, and the output is a request message sent to the server. This message also includes the user ID, the current timestamp, and other information.

[0275] Step 3:

[0276] When the server receives a request, it randomly selects a topic from the topic database. Specifically, it uses the server's random selection algorithm. The input is the request message and the topic database, and the output is the randomly selected topic. During this process, the server also obtains emotion data from the emotion engine.

[0277] Step 4:

[0278] The server adjusts the selected topic as needed based on the emotional data it obtains. For example, if the emotional data indicates that the user is in a relaxed state, the server will preferentially select a relaxing topic such as "What did you do on your recent holiday?" The input is the emotional data and a randomly selected topic, and the output is the adjusted topic.

[0279] Step 5:

[0280] The server sends the adjusted topic to the terminal in JSON format. Specifically, it converts the topic data into JSON format and generates a network request to send it to the terminal. The input is the adjusted topic, and the output is JSON-formatted data. This data is sent via an HTTP request.

[0281] Step 6:

[0282] The terminal receives the JSON data from the server, parses it, and displays it to the user. Specifically, the terminal parses the received JSON data and displays the topic "What is your favorite food?" on the screen. The input is the JSON data from the server, and the output is a display of the topic that the user can check.

[0283] Step 7:

[0284] The device communicates with the emotion engine to collect the user's emotional data. The emotion engine automatically analyzes the user's voice, facial expressions, and text data to determine their emotional state. The input is the user's real-time data, and the output is the analyzed emotional data.

[0285] Step 8:

[0286] The device sends the collected emotion data to the server. The input is the emotion data obtained from the emotion engine, and the output is the data sent to the server. The server can then use this data to select a topic for the next time.

[0287] Through this process, the system provides users with natural conversation topics and utilizes emotional data to select more appropriate topics.

[0288] (Application example 2)

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

[0290] Conventional conversation support systems lack the means to provide appropriate topics for users to initiate conversations naturally and smoothly. Furthermore, because they randomly provide topics without considering the user's emotional state, users may encounter topics that are uninteresting. In particular, in brick-and-mortar stores, where direct interaction with customers is common, the lack of such a system hinders smooth customer service. To solve these issues, it is necessary for randomly generated conversation topics to adapt to the user's emotional state.

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

[0292] In this invention, the server includes information processing means having a storage device for generating random topics, terminal means for sending a topic generation request to the information processing means, means for sending the topic randomly selected by the information processing means to the terminal means and displaying the received topic, emotion analysis means for identifying an emotional state using emotion recognition means and sending emotion data to the information processing means, and means for adjusting the topic selected by the information processing means based on the emotion data. This makes it possible to provide an appropriate topic adapted to the emotional state of the user, thereby realizing a natural and smooth start to conversation.

[0293] The "information processing device means" is a device that has a memory device and algorithms for generating random topics, and selects and transmits topics in response to a topic generation request from a terminal.

[0294] The "terminal means" is a device that transmits a topic generation request to the information processing means and displays the received topic. It is used by being operated by a user.

[0295] "Storage" refers to a database for storing multiple topics and randomly selecting from the topics.

[0296] The "emotion recognition means" is a system that analyzes the user's voice, facial expression, behavior, etc. to identify the user's emotional state.

[0297] The "emotion analysis means" is a means for transmitting emotion data analyzed by the emotion recognition means to the information processing means.

[0298] A "topic creation request" is a request sent from a terminal means to an information processing device means, and refers to a request to create a new topic.

[0299] An "interactive user interface" is an interface that uses user-identified topics as conversation starters and is designed to be easy for users to operate.

[0300] The present invention relates to a random topic generation system for promoting natural conversations with customers, and in particular to a system that supports store clerks in brick-and-mortar stores in smoothly starting communication with customers.

[0301] The server has a storage device for generating random topics, and a database stores multiple topics. This storage device contains topics such as "What book have you read recently?" and "Where would you like to go on vacation?" The server transmits the randomly selected topic to the terminal using a stored algorithm. The server also has a means for adjusting the selected topic based on emotion data from the emotion recognition means.

[0302] The terminal is a device operated by a store clerk, such as a smartphone or tablet. An application is launched on the terminal, and a topic generation request is sent to the server. The topic received from the server is displayed to the store clerk via the terminal's interactive user interface. The store clerk can then start a conversation with the customer based on the displayed topic.

[0303] The emotion analysis means analyzes the conversation between the store clerk and the customer, as well as the customer's facial expressions and voice in real time to obtain emotional data. For example, it uses the camera and microphone built into a smartphone or tablet to analyze the user's facial expressions and voice. The analysis results are recognized in real time by the emotion recognition means and sent to the server. Based on this emotional data, the server can select topics that are appropriate for the customer's emotional state.

[0304] As a specific example, when a waiter holds a smartphone and clicks a button to generate a new topic, a request is sent to the server, and the topic "What is your favorite dish?" is received and displayed. If the emotion analysis means detects a relaxed expression on the customer's face, a more relaxed topic will be selected first. This allows the waiter to start a smooth conversation with the customer.

[0305] An example prompt is, "We are developing an app that allows store associates in physical stores to suggest appropriate topics to talk about when starting a conversation with a customer based on the customer's emotional state. If the customer is smiling, we suggest relaxing topics, and if the customer has a surprised expression, we suggest interesting topics. What specific topics would be appropriate?"

[0306] In this way, the present invention supports natural and effective communication by providing topics that adapt to the customer's emotional state.

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

[0308] Step 1:

[0309] A user launches the application on their device (smartphone or tablet) and clicks a button to create a new topic.

[0310] This operation causes the terminal to send a topic generation request to the server. The input is the user's button click action, and the output is the request data sent to the server.

[0311] Step 2:

[0312] When the server receives a request to generate a topic, it randomly selects a topic from a database in a storage device.

[0313] In this case, the server uses a topic selection algorithm to select one topic from multiple topics and sends the selected topic to the terminal. The input is a topic generation request, and the output is randomly selected topic data.

[0314] Step 3:

[0315] The terminal analyzes the topic data received from the server and displays it to the user through an interactive user interface.

[0316] Specifically, topics are displayed in text format on the screen and provided in a form that can be viewed by the user. The input is topic data from the server, and the output is topic information displayed on the screen.

[0317] Step 4:

[0318] As soon as the user is presented with a topic, the device uses its built-in emotion recognition means (camera and microphone) to analyze the user's facial expressions and voice.

[0319] It identifies the user's emotional state in real time and sends the data to an emotion analysis means. The input is the user's facial expression and voice data, and the output is analyzed emotional data.

[0320] Step 5:

[0321] The emotion analysis means analyzes the acquired emotion data and transmits it to the server.

[0322] Specifically, the emotion recognition model determines the user's emotional state (e.g., relaxed, excited, etc.) and sends the result as data to the server. The input is the analysis result of the user's facial expression and voice, and the output is emotional data.

[0323] Step 6:

[0324] The server selects a new appropriate topic based on the received emotion data.

[0325] Based on the data from the emotion recognition means, the topic selection algorithm recalculates the optimal topic and sends the adjusted topic back to the terminal. The input is emotion data, and the output is adjusted topic data.

[0326] Step 7:

[0327] The terminal again displays the adjusted topic received from the server to the user.

[0328] The initially displayed topic is replaced with a new topic that is adapted to the user's emotional state and presented in a user-friendly format. The input is the adjusted topic data, and the output is the new topic displayed to the user.

[0329] This series of processes allows the user to select an appropriate topic according to their emotional state, allowing them to start a conversation naturally and smoothly.

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

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

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

[0333] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0346] The system of the present invention generates and displays random topics for users to use as conversation starters. The system has the roles of a server, a terminal, and a user, which are described below.

[0347] Server Operation

[0348] The server maintains a topic database, which stores multiple topics. When the server starts, it first loads this topic database into memory. When it receives a topic generation request from a user, the server randomly selects one topic from the database. The selected topic is sent to the terminal in JSON format.

[0349] As a concrete example, suppose the server loads a database with topics such as "What language have you written recently?" and "What is your favorite food?", and then randomly selects "What is your favorite food?" This selected topic is sent to the device.

[0350] Device behavior

[0351] The terminal is a device operated by the user. When the user launches the app and clicks a specific button, the terminal sends a topic creation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user.

[0352] Specifically, when a user clicks the "Generate a new topic" button, the device sends a request to the server and receives the topic "What is your favorite food?" from the server. The device displays this on the screen so that the user can check it.

[0353] User operations

[0354] Users simply launch the application on their device and click a button to generate a new topic, which they will receive as a conversation starter, allowing them to easily start a conversation and communicate naturally.

[0355] For example, if a user launches the app before a morning meeting and clicks the "Generate a new topic" button, the device sends a request to the server, which then displays a randomly selected topic, such as "What's your favorite food?", which the user can use to start a conversation with their colleagues.

[0356] In this way, the system of the present invention provides users with random topics through communication between the server and the terminal, helping them to start conversations naturally. The server's topic database, random selection algorithm, and terminal interface work together to create a system that is highly convenient for users.

[0357] The processing flow will be explained below.

[0358] Server-side processing steps

[0359] Step 1:

[0360] The server starts and loads the topic database, which contains multiple topics. For example, the database might contain questions like "What language have you written in recently?" or "What is your favorite food?"

[0361] Step 2:

[0362] The server waits for an HTTP GET request to a specific endpoint (e.g., / get_random_topic).

[0363] Step 3:

[0364] The server receives a topic creation request from a terminal. This request is for the creation of a topic.

[0365] Step 4:

[0366] The server randomly selects a topic from the topic database using the Python function random.choice() .

[0367] Step 5:

[0368] The server sends the selected topic in JSON format to the terminal, and the response includes the selected topic.

[0369] Terminal processing steps

[0370] Step 1:

[0371] The terminal will start up and display a user interface where the user can see a "Create a new topic" button.

[0372] Step 2:

[0373] The user clicks the "Create a new topic" button. This action causes the device to send a topic creation request to the server.

[0374] Step 3:

[0375] The server receives the request sent by the terminal and receives a response containing a randomly selected topic from the server.

[0376] Step 4:

[0377] The device parses the response from the server and extracts the topic from the JSON data included in the response.

[0378] Step 5:

[0379] The terminal displays the extracted topics on the user interface, allowing the user to check the displayed topics.

[0380] User operation steps

[0381] Step 1:

[0382] The user launches the app, which prepares the device for topic generation.

[0383] Step 2:

[0384] The user clicks the "Create a new topic" button, which causes the device to send a topic creation request to the server.

[0385] Step 3:

[0386] The user checks the topic displayed on the device. For example, the topic "What is your favorite food?" is displayed.

[0387] Step 4:

[0388] Users can start conversations based on the displayed topics, which promotes natural communication.

[0389] Example 1

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

[0391] Conventional methods for starting conversations require users to come up with topics themselves, which is time-consuming and inefficient. Furthermore, systems that use fixed topics lack freshness and make it difficult to promote natural communication. Therefore, a system that allows users to quickly and easily obtain new conversation starters was needed.

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

[0393] In this invention, the server includes a means for maintaining a topic database and loading it into memory when the server starts up, a means including an algorithm for receiving a topic generation request from a user and randomly selecting one topic from the database, and a means for converting the selected topic into JSON format and sending it to a terminal, thereby enabling users to quickly and easily obtain new conversation starters.

[0394] A "topic database" is a database for storing multiple topics that serve as conversation starters.

[0395] "Loading into memory" means reading the contents of the database into the main memory device for temporary storage at startup.

[0396] A "topic creation request" is an action in which a user requests the server to create a new topic via a terminal.

[0397] A "random selection algorithm" is a computational method for randomly selecting one of the topics in a topic database.

[0398] "JSON format" is an abbreviation for JavaScript Object Notation, and is a data format that structures data in text format and makes it exchangeable.

[0399] A "terminal" is an electronic device such as a computer or smartphone that is operated by a user.

[0400] A "response" is response data sent from a server to a terminal.

[0401] A "user" is a person who operates the system to send topic creation requests and review the created topics.

[0402] An "interface" is a screen or operating means for displaying topics to a user on a terminal.

[0403] A specific embodiment of the system of the present invention, which generates and displays random topics for users to use as conversation starters, is described below.

[0404] Server Operation

[0405] The server maintains a topic database. When the server starts, it first loads this topic database into memory. This database stores multiple topics that can serve as conversation starters. When the server receives a topic generation request from a user, it randomly selects one topic from the database. The selected topic is converted into JSON format and sent to the terminal. Server processing can be achieved, for example, by using Python's random.choice function.

[0406] Device behavior

[0407] The terminal is a device operated by the user. When the user launches a dedicated application and clicks the "Create a new topic" button, the terminal sends an HTTP request to the server. This request is a request to create a topic. When the terminal receives a response from the server, it parses the received JSON data and extracts the topic text. The extracted text is displayed to the user. The display interface of the terminal is realized using, for example, HTML and JavaScript.

[0408] User operations

[0409] Users simply launch the application on their device and click a button to generate a new topic, which they will receive as a conversation starter, allowing them to easily start a conversation and communicate naturally.

[0410] Examples and behavior

[0411] For example, the topic database contains topics such as "What language have you written recently?" and "What is your favorite food?" When a user clicks the "Generate a new topic" button, the device sends a request to the server, which randomly selects the topic "What is your favorite food?" and sends it to the device. The device then displays it on the screen so that the user can check it.

[0412] Examples of prompt statements

[0413] Examples of prompts for a generative AI model might include:

[0414] "When a user clicks the 'Generate a new topic' button on their device, how do I have the server randomly select a topic and send it to the device?"

[0415] "Please tell me how the server selects a random topic and sends it to the device."

[0416] In this way, by having the roles of the server, terminal, and user work in cooperation with each other, the user can quickly and easily get a conversation start. The present invention contributes to smoother conversation and promotion of communication.

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

[0418] Step 1: Start the server

[0419] When the server starts, it loads the topic database into memory. The server reads the topic database file from local or remote storage and stores it in memory (e.g., RAM), allowing the server to quickly access all the topics in the topic database.

[0420] Input: topic database file

[0421] Output: Topic database loaded in memory

[0422] Step 2: User clicks a button

[0423] The user launches a dedicated application and clicks the "Create a new topic" button, which sends a creation request from the device to the server. The request is usually executed as an HTTP POST request.

[0424] Input: User clicks a button

[0425] Output: HTTP POST request to the server

[0426] Step 3: Receiving the request on the server

[0427] The server receives a request to create a topic from a user. The server parses the HTTP request and verifies that the request is for creating a topic.

[0428] Input: HTTP POST request

[0429] Output: Recognition of topic creation request

[0430] Step 4: Random Topic Selection

[0431] The server retrieves all topics in the topic database and uses a random algorithm (e.g., Python's random.choice function) to select one topic, which is later converted to JSON format.

[0432] Input: Topic database

[0433] Output: Randomly chosen topics

[0434] Step 5: Converting Topics to JSON Format

[0435] The server converts the selected topics into JSON format, for example using the Python json.dumps function.

[0436] Input: A randomly selected topic

[0437] Output: Topic data in JSON format

[0438] Step 6: Submit to Topic

[0439] The server converts the topic into JSON format and sends it to the terminal as an HTTP response, which also includes an HTTP status code and header information.

[0440] Input: JSON formatted topic data

[0441] Output: HTTP response to the device

[0442] Step 7: Receiving and Parsing the Response

[0443] The device receives the HTTP response from the server and parses the response using the JavaScript JSON.parse function or similar.

[0444] Input: HTTP response

[0445] Output: Parsed topic data

[0446] Step 8: Viewing Topics

[0447] The device displays the parsed topic data to the user, using the device's interface (e.g., HTML elements or UI components of a mobile app).

[0448] Input: Parsed topic data

[0449] Output: A user-visible topic display

[0450] In this way, random topics are provided to users and can be used as conversation starters.

[0451] (Application example 1)

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

[0453] Conventional systems have difficulty not only generating and displaying topics that allow users to naturally start conversations, but also providing appropriate topics according to specific contexts and purposes. Furthermore, while effective customer support is required in virtual stores, existing methods are sometimes unable to adequately address this need. This has led to a demand for improved user experience and customer satisfaction.

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

[0455] In this invention, the server includes means for having a database for generating random topics, terminal means for sending topic generation requests, means for sending randomly selected topics to the terminal means and displaying the received topics, and means for using a generative AI model to generate topics that can be used as conversation starters, thereby enabling users to provide appropriate topics for specific contexts in customer support within a virtual store, rather than simply receiving random topics.

[0456] "Server means" refers to a device that has a database for generating random topics, receives a topic generation request, and has the function of sending a randomly selected topic to a terminal means, or software that implements that function.

[0457] The "terminal means" is a device that is operated by a user to send a topic generation request to the server means, and receives and displays the topic sent from the server, or software that implements the function thereof.

[0458] A "generative AI model" is an artificial intelligence algorithm or system that generates topics that can be used as conversation starters in a given context.

[0459] A "prompt sentence" is text data that is input into a generative AI model to generate an appropriate topic.

[0460] A "topic database" is a database that stores multiple topics and is used by the server means.

[0461] The following describes in detail the mode for carrying out the present invention. The system of the present invention supports users in starting conversations naturally by generating and displaying random topics. Specific embodiments will be described below.

[0462] Server Operation

[0463] The server maintains a topic database, which stores a large number of topics. When the server starts up, it first loads this topic database into memory. When it receives a topic generation request from a user, the server randomly selects a topic from the database. At this time, it uses a generative AI model to generate a prompt sentence to generate a topic appropriate for the specific context and purpose. The selected topic is sent to the terminal in JSON format.

[0464] For example, the server loads a database with topics such as "What is your favorite product these days?" and "Which product are you interested in?", then randomly selects "Which product are you interested in?", and this selected topic is sent to the device.

[0465] Device behavior

[0466] The terminal is a device operated by the user. When the user launches an application and clicks a specific button, the terminal sends a topic creation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user.

[0467] Specifically, when a user clicks the "Generate a new topic" button, the device sends a request to the server and receives the topic "Which product are you interested in?" from the server. The device displays this on the screen so that the user can check it.

[0468] User operations

[0469] Users simply launch the application on their device and click a button to create a new topic, which they will then receive as a conversation starter, allowing them to easily start a conversation and communicate naturally.

[0470] For example, consider a case where a user visits a virtual store and uses a customer support app. When the user clicks the "Generate a new topic" button, the device sends a request to the server, and the server randomly selects a topic, such as "Which product are you interested in?". The user can then start a conversation with the virtual assistant based on this topic.

[0471] Hardware and software used

[0472] Server: A powerful computer or cloud instance

[0473] Devices: smartphones, tablets, head-mounted displays

[0474] Software: Flask (a Python web framework), generative AI models (e.g., GPT-3)

[0475] Examples of prompts include:

[0476] "Randomly generate topics to start a conversation with your customers. For example: What's your favorite product these days?"

[0477] By combining these elements, the system of the present invention can provide users with highly convenient conversation starters and improve the quality of customer support in virtual stores.

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

[0479] Step 1:

[0480] A user starts the application and clicks the "Create a new topic" button. This action causes the device to send a topic creation request to the server. The input is the user's button click, and the output is an HTTP request that sends a topic creation request to the server.

[0481] Step 2:

[0482] When the server receives a topic generation request, it loads the topic database into memory. The input is the topic generation request, and the output is the loading of the topic database. The server internally generates a prompt using a generative AI model, and selects a topic based on this prompt.

[0483] Step 3:

[0484] The server uses a generative AI model to randomly generate topics from a topic database. Specifically, it inputs a prompt sentence into the generative AI model and obtains an appropriate topic as the output. The input is the prompt sentence and the topic database, and the output is a randomly selected topic.

[0485] Step 4:

[0486] The server converts the selected topic into JSON format and sends it to the terminal. The input is a randomly selected topic, and the output is JSON format data. The server returns this JSON data to the terminal as a response using the HTTP protocol.

[0487] Step 5:

[0488] The terminal receives a JSON-formatted response from the server and parses the data to extract the topic. The input is the received JSON data, and the output is the parsed topic. Specifically, the terminal parses the data using a JSON parser.

[0489] Step 6:

[0490] The terminal displays the extracted topics on the user interface. The input is the analyzed topic, and the output is the topic displayed on the user interface. The user can check this and use it as a conversation starter. Specifically, the topic is displayed in text format on the display.

[0491] This series of processing steps allows users to easily find suitable topics to start a conversation, enabling effective customer support, especially in scenarios such as virtual stores.

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

[0493] The system of the present invention generates and displays random topics for users to use as conversation starters, and also combines an emotion engine that recognizes the user's emotions. This system has the roles of a server, a terminal, an emotion engine, and a user, which are described below.

[0494] Server Operation

[0495] The server maintains a topic database, which stores multiple topics. When the server starts up, it first loads this topic database into memory. When it receives a topic generation request from a user, the server randomly selects one topic from the database. The selected topic is sent to the device in JSON format. It can also receive emotion data from the emotion engine and adjust the selected topic.

[0496] For example, the server loads a database with topics such as "What language have you written recently?" and "What is your favorite food?", and then randomly selects "What is your favorite food?" If the emotion engine detects that the user is excited, the server will prioritize selecting a more relaxed topic. This selected topic is then sent to the device.

[0497] Device behavior

[0498] The terminal is a device operated by the user. When the user launches the app and clicks a specific button, the terminal sends a topic generation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user. In addition, the terminal communicates with the emotion engine and sends the user's emotion data to the server.

[0499] Specifically, when a user clicks the "Generate a new topic" button, the device sends a request to the server and receives the topic "What is your favorite food?" from the server. The device displays this on the screen so that the user can confirm it. At the same time, emotion data from the emotion engine is sent to the server.

[0500] Emotion Engine Operation

[0501] The emotion engine recognizes emotions by analyzing the user's voice, facial expressions, or input data. Emotion data is acquired and analyzed in real time. This data is sent to the server via the device and used as a reference for further topic selection.

[0502] For example, if a user is smiling, the emotion engine will interpret this as a "positive emotion" and send it to the server, which can then prioritize more lively topics.

[0503] User operations

[0504] Users simply launch the application on their device and click the button to generate a new topic, which they receive as a conversation starter. This allows users to easily start a conversation and promote natural communication. Additionally, the emotion engine evaluates the user's emotional state in real time and provides the most appropriate topic based on the results.

[0505] For example, if a user starts the app before a morning meeting and clicks the "Generate a new topic" button, the device sends a request to the server, which then displays a topic that matches the user's emotion, such as "What is your favorite food?". The user can then start a conversation with their colleagues based on this topic.

[0506] In this way, the system of the present invention supports users in starting a conversation naturally by having the server, terminal, and emotion engine work together to provide random and appropriate topics to the user.

[0507] The processing flow will be explained below.

[0508] Server-side processing steps

[0509] Step 1:

[0510] The server starts and loads the topic database, which contains multiple topics, such as "What language have you written in recently?" or "What is your favorite food?"

[0511] Step 2:

[0512] The server waits for an HTTP GET request to a specific endpoint (e.g., / get_random_topic).

[0513] Step 3:

[0514] The server receives a topic creation request from a terminal. This request is for the creation of a topic.

[0515] Step 4:

[0516] The server receives the user's emotional data from the emotion engine, the emotional data including the user's current emotional state.

[0517] Step 5:

[0518] The server randomly selects a topic from the topic database using the Python function random.choice() .

[0519] Step 6:

[0520] The server adjusts the randomly selected topics by taking into account emotional data, for example, prioritizing relaxing topics if the user is feeling stressed.

[0521] Step 7:

[0522] The server sends the selected topic in JSON format to the terminal, and the response includes the selected topic.

[0523] Terminal processing steps

[0524] Step 1:

[0525] The terminal will start up and display a user interface where the user can see a "Create a new topic" button.

[0526] Step 2:

[0527] The user clicks the "Create a new topic" button. This action causes the device to send a topic creation request to the server.

[0528] Step 3:

[0529] The terminal collects the user's emotional data through an emotion engine, which includes the user's voice, facial expression, or input data.

[0530] Step 4:

[0531] The terminal transmits this emotion data to the server.

[0532] Step 5:

[0533] The terminal receives a response from the server that includes the topic.

[0534] Step 6:

[0535] The terminal analyzes the response received and extracts the topic.

[0536] Step 7:

[0537] The terminal displays the extracted topics on the user interface, allowing the user to check the displayed topics.

[0538] Emotion Engine Processing Steps

[0539] Step 1:

[0540] The emotion engine collects the user's voice, facial expressions, or input data.

[0541] Step 2:

[0542] The emotion engine analyzes the collected data and recognizes the user's emotional state.

[0543] Step 3:

[0544] The emotion data recognized by the emotion engine is sent to the server via the terminal.

[0545] User operation steps

[0546] Step 1:

[0547] The user launches the app, which prepares the device for topic generation.

[0548] Step 2:

[0549] The user clicks the "Create a new topic" button, which causes the device to send a topic creation request to the server.

[0550] Step 3:

[0551] The user checks the topic displayed on the device. For example, the topic "What is your favorite food?" is displayed.

[0552] Step 4:

[0553] Users can start conversations based on the displayed topics, which promotes natural communication.

[0554] Example 2

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

[0556] Conventional conversation starter systems provide random topics without considering the user's emotional state, making it difficult to provide a topic appropriate to the user's current emotions and situation. Furthermore, if the randomly selected topic does not match the user's preferences or emotional state, the conversation may start unnaturally. This can lead to a poor communication experience for the user.

[0557] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a processing device having data storage for generating random topics, a display device that sends a topic generation request to the processing device, a device that sends the topic randomly selected by the processing device to the display device and displays the received topic, a device that acquires emotional data from the display device and sends it to the processing device, and a device that adjusts the topic based on the emotional data from the processing device. This makes it possible to start a more natural and effective conversation by providing a topic that suits the user's emotional state.

[0558] A "processing device" is an electronic device capable of manipulating data and performing a particular function or service.

[0559] A "display device" is an electronic device that provides an interface for a user to visually confirm information.

[0560] "Data storage" is a storage device for storing information and data for long periods of time.

[0561] A "topic creation request" is an operation or message that a user sends to the server requesting the creation of a new topic.

[0562] "Random selection" is a method of selecting randomly without following any particular rule or order.

[0563] "Emotion data" is information that indicates the user's current emotional state, and is extracted from voice, facial expressions, and text data.

[0564] A "tuning device" is a device that has the ability to change or optimize the content of a selected topic based on acquired data.

[0565] This invention provides a system that generates random topics to prompt users to start a conversation and displays them to them. Furthermore, it supports more natural and effective communication by assessing the user's emotional state in real time and providing optimal topics based on that information.

[0566] Server configuration and operation

[0567] The server maintains a topic database, which stores various conversation topics. When the server starts up, the topic database is loaded into memory. When the server receives a topic generation request from a user, it randomly selects one topic from the database. This selected topic is sent to the device in JSON format. It also receives emotion data from the emotion engine and adjusts the topic selection based on that data.

[0568] For example, if the server stores topics such as "What did you do on your recent holiday?" and "What is your favorite food?" in a database, and a user sends a request, the server randomly selects the topic "What is your favorite food?" If the emotion engine evaluates the user's emotional state as "Relaxed," the server can prioritize topics such as "What did you do on your recent holiday?"

[0569] Terminal configuration and operation

[0570] The terminal is a device operated by the user, on which the user launches the application. When the user clicks the "Create a new topic" button, the terminal sends a topic creation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user. Furthermore, the terminal communicates with the emotion engine and sends the user's emotion data to the server.

[0571] For example, a user clicks the "Generate a new topic" button and receives the topic "What is your favorite food?" from the server. This topic will be displayed on the device screen, and the user can see it and start a conversation. At the same time, the device will collect the user's emotion data from the emotion engine and send it to the server in real time.

[0572] Emotion engine configuration and operation

[0573] The emotion engine analyzes the user's voice, facial expressions, and text to evaluate the user's emotional state in real time. This emotional data is sent to the server via the device and used as reference information for the server to select topics.

[0574] For example, if a user is smiling while looking at the app, the emotion engine will interpret this as a "positive emotion" and send that data to the server, which can then choose lively topics appropriate for the user.

[0575] Examples and prompts

[0576] As a concrete example, suppose a user launches the app during their morning commute and clicks the "Generate a new topic" button. The device sends a request to the server, which returns the topic "What is your favorite travel destination?" This information is displayed on the device, allowing the user to start a conversation with people around them.

[0577] An example of a prompt is:

[0578] "If the user is excited, choose a topic that will generate a relaxed buzz."

[0579] "Choose a conversation topic that's appropriate for when the user is sad."

[0580] Examples include:

[0581] In this way, the system's server, terminal, and emotion engine work together to provide users with appropriate conversation topics and support natural communication.

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

[0583] Step 1:

[0584] When the server starts up, it loads the topic database into memory. Specifically, it reads multiple conversation topics stored in the topic database into the server's memory. At this point, the database contains topics such as "What is your favorite food?" and "What did you do on your last holiday?" The input is the topic database, and the output is the topic list loaded into memory. This allows the server to be ready to quickly select a topic at any time.

[0585] Step 2:

[0586] A user launches the app on their device and clicks the "Create a new topic" button. This causes the device to send a topic creation request to the server. The input is the user's click, and the output is a request message sent to the server. This message also includes the user ID, the current timestamp, and other information.

[0587] Step 3:

[0588] When the server receives a request, it randomly selects a topic from the topic database. Specifically, it uses the server's random selection algorithm. The input is the request message and the topic database, and the output is the randomly selected topic. During this process, the server also obtains emotion data from the emotion engine.

[0589] Step 4:

[0590] The server adjusts the selected topic as needed based on the emotional data it obtains. For example, if the emotional data indicates that the user is in a relaxed state, the server will preferentially select a relaxing topic such as "What did you do on your recent holiday?" The input is the emotional data and a randomly selected topic, and the output is the adjusted topic.

[0591] Step 5:

[0592] The server sends the adjusted topic to the terminal in JSON format. Specifically, it converts the topic data into JSON format and generates a network request to send it to the terminal. The input is the adjusted topic, and the output is JSON-formatted data. This data is sent via an HTTP request.

[0593] Step 6:

[0594] The terminal receives the JSON data from the server, parses it, and displays it to the user. Specifically, the terminal parses the received JSON data and displays the topic "What is your favorite food?" on the screen. The input is the JSON data from the server, and the output is a display of the topic that the user can check.

[0595] Step 7:

[0596] The device communicates with the emotion engine to collect the user's emotional data. The emotion engine automatically analyzes the user's voice, facial expressions, and text data to determine their emotional state. The input is the user's real-time data, and the output is the analyzed emotional data.

[0597] Step 8:

[0598] The device sends the collected emotion data to the server. The input is the emotion data obtained from the emotion engine, and the output is the data sent to the server. The server can then use this data to select a topic for the next time.

[0599] Through this process, the system provides users with natural conversation topics and utilizes emotional data to select more appropriate topics.

[0600] (Application example 2)

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

[0602] Conventional conversation support systems lack the means to provide appropriate topics for users to initiate conversations naturally and smoothly. Furthermore, because they randomly provide topics without considering the user's emotional state, users may encounter topics that are uninteresting. In particular, in brick-and-mortar stores, where direct interaction with customers is common, the lack of such a system hinders smooth customer service. To solve these issues, it is necessary for randomly generated conversation topics to adapt to the user's emotional state.

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

[0604] In this invention, the server includes information processing means having a storage device for generating random topics, terminal means for sending a topic generation request to the information processing means, means for sending the topic randomly selected by the information processing means to the terminal means and displaying the received topic, emotion analysis means for identifying an emotional state using emotion recognition means and sending emotion data to the information processing means, and means for adjusting the topic selected by the information processing means based on the emotion data. This makes it possible to provide an appropriate topic adapted to the emotional state of the user, thereby realizing a natural and smooth start to conversation.

[0605] The "information processing device means" is a device that has a memory device and algorithms for generating random topics, and selects and transmits topics in response to a topic generation request from a terminal.

[0606] The "terminal means" is a device that transmits a topic generation request to the information processing means and displays the received topic. It is used by being operated by a user.

[0607] "Storage" refers to a database for storing multiple topics and randomly selecting from the topics.

[0608] The "emotion recognition means" is a system that analyzes the user's voice, facial expression, behavior, etc. to identify the user's emotional state.

[0609] The "emotion analysis means" is a means for transmitting emotion data analyzed by the emotion recognition means to the information processing means.

[0610] A "topic creation request" is a request sent from a terminal means to an information processing device means, and refers to a request to create a new topic.

[0611] An "interactive user interface" is an interface that uses user-identified topics as conversation starters and is designed to be easy for users to operate.

[0612] The present invention relates to a random topic generation system for promoting natural conversations with customers, and in particular to a system that supports store clerks in brick-and-mortar stores in smoothly starting communication with customers.

[0613] The server has a storage device for generating random topics, and a database stores multiple topics. This storage device contains topics such as "What book have you read recently?" and "Where would you like to go on vacation?" The server transmits the randomly selected topic to the terminal using a stored algorithm. The server also has a means for adjusting the selected topic based on emotion data from the emotion recognition means.

[0614] The terminal is a device operated by a store clerk, such as a smartphone or tablet. An application is launched on the terminal, and a topic generation request is sent to the server. The topic received from the server is displayed to the store clerk via the terminal's interactive user interface. The store clerk can then start a conversation with the customer based on the displayed topic.

[0615] The emotion analysis means analyzes the conversation between the store clerk and the customer, as well as the customer's facial expressions and voice in real time to obtain emotional data. For example, it uses the camera and microphone built into a smartphone or tablet to analyze the user's facial expressions and voice. The analysis results are recognized in real time by the emotion recognition means and sent to the server. Based on this emotional data, the server can select topics that are appropriate for the customer's emotional state.

[0616] As a specific example, when a waiter holds a smartphone and clicks a button to generate a new topic, a request is sent to the server, and the topic "What is your favorite dish?" is received and displayed. If the emotion analysis means detects a relaxed expression on the customer's face, a more relaxed topic will be selected first. This allows the waiter to start a smooth conversation with the customer.

[0617] An example prompt is, "We are developing an app that allows store associates in physical stores to suggest appropriate topics to talk about when starting a conversation with a customer based on the customer's emotional state. If the customer is smiling, we suggest relaxing topics, and if the customer has a surprised expression, we suggest interesting topics. What specific topics would be appropriate?"

[0618] In this way, the present invention supports natural and effective communication by providing topics that adapt to the customer's emotional state.

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

[0620] Step 1:

[0621] A user launches the application on their device (smartphone or tablet) and clicks a button to create a new topic.

[0622] This operation causes the terminal to send a topic generation request to the server. The input is the user's button click action, and the output is the request data sent to the server.

[0623] Step 2:

[0624] When the server receives a request to generate a topic, it randomly selects a topic from a database in a storage device.

[0625] In this case, the server uses a topic selection algorithm to select one topic from multiple topics and sends the selected topic to the terminal. The input is a topic generation request, and the output is randomly selected topic data.

[0626] Step 3:

[0627] The terminal analyzes the topic data received from the server and displays it to the user through an interactive user interface.

[0628] Specifically, topics are displayed in text format on the screen and provided in a form that can be viewed by the user. The input is topic data from the server, and the output is topic information displayed on the screen.

[0629] Step 4:

[0630] As soon as the user is presented with a topic, the device uses its built-in emotion recognition means (camera and microphone) to analyze the user's facial expressions and voice.

[0631] It identifies the user's emotional state in real time and sends the data to an emotion analysis means. The input is the user's facial expression and voice data, and the output is analyzed emotional data.

[0632] Step 5:

[0633] The emotion analysis means analyzes the acquired emotion data and transmits it to the server.

[0634] Specifically, the emotion recognition model determines the user's emotional state (e.g., relaxed, excited, etc.) and sends the result as data to the server. The input is the analysis result of the user's facial expression and voice, and the output is emotional data.

[0635] Step 6:

[0636] The server selects a new appropriate topic based on the received emotion data.

[0637] Based on the data from the emotion recognition means, the topic selection algorithm recalculates the optimal topic and sends the adjusted topic back to the terminal. The input is emotion data, and the output is adjusted topic data.

[0638] Step 7:

[0639] The terminal again displays the adjusted topic received from the server to the user.

[0640] The initially displayed topic is replaced with a new topic that is adapted to the user's emotional state and presented in a user-friendly format. The input is the adjusted topic data, and the output is the new topic displayed to the user.

[0641] This series of processes allows the user to select an appropriate topic according to their emotional state, allowing them to start a conversation naturally and smoothly.

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

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

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

[0645] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0658] The system of the present invention generates and displays random topics for users to use as conversation starters. The system has the roles of a server, a terminal, and a user, which are described below.

[0659] Server Operation

[0660] The server maintains a topic database, which stores multiple topics. When the server starts, it first loads this topic database into memory. When it receives a topic generation request from a user, the server randomly selects one topic from the database. The selected topic is sent to the terminal in JSON format.

[0661] As a concrete example, suppose the server loads a database with topics such as "What language have you written recently?" and "What is your favorite food?", and then randomly selects "What is your favorite food?" This selected topic is sent to the device.

[0662] Device behavior

[0663] The terminal is a device operated by the user. When the user launches the app and clicks a specific button, the terminal sends a topic creation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user.

[0664] Specifically, when a user clicks the "Generate a new topic" button, the device sends a request to the server and receives the topic "What is your favorite food?" from the server. The device displays this on the screen so that the user can check it.

[0665] User operations

[0666] Users simply launch the application on their device and click a button to generate a new topic, which they will receive as a conversation starter, allowing them to easily start a conversation and communicate naturally.

[0667] For example, if a user launches the app before a morning meeting and clicks the "Generate a new topic" button, the device sends a request to the server, which then displays a randomly selected topic, such as "What's your favorite food?", which the user can use to start a conversation with their colleagues.

[0668] In this way, the system of the present invention provides users with random topics through communication between the server and the terminal, helping them to start conversations naturally. The server's topic database, random selection algorithm, and terminal interface work together to create a system that is highly convenient for users.

[0669] The processing flow will be explained below.

[0670] Server-side processing steps

[0671] Step 1:

[0672] The server starts and loads the topic database, which contains multiple topics. For example, the database might contain questions like "What language have you written in recently?" or "What is your favorite food?"

[0673] Step 2:

[0674] The server waits for an HTTP GET request to a specific endpoint (e.g., / get_random_topic).

[0675] Step 3:

[0676] The server receives a topic creation request from a terminal. This request is for the creation of a topic.

[0677] Step 4:

[0678] The server randomly selects a topic from the topic database using the Python function random.choice() .

[0679] Step 5:

[0680] The server sends the selected topic in JSON format to the terminal, and the response includes the selected topic.

[0681] Terminal processing steps

[0682] Step 1:

[0683] The terminal will start up and display a user interface where the user can see a "Create a new topic" button.

[0684] Step 2:

[0685] The user clicks the "Create a new topic" button. This action causes the device to send a topic creation request to the server.

[0686] Step 3:

[0687] The server receives the request sent by the terminal and receives a response containing a randomly selected topic from the server.

[0688] Step 4:

[0689] The device parses the response from the server and extracts the topic from the JSON data included in the response.

[0690] Step 5:

[0691] The terminal displays the extracted topics on the user interface, allowing the user to check the displayed topics.

[0692] User operation steps

[0693] Step 1:

[0694] The user launches the app, which prepares the device for topic generation.

[0695] Step 2:

[0696] The user clicks the "Create a new topic" button, which causes the device to send a topic creation request to the server.

[0697] Step 3:

[0698] The user checks the topic displayed on the device. For example, the topic "What is your favorite food?" is displayed.

[0699] Step 4:

[0700] Users can start conversations based on the displayed topics, which promotes natural communication.

[0701] Example 1

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

[0703] Conventional methods for starting conversations require users to come up with topics themselves, which is time-consuming and inefficient. Furthermore, systems that use fixed topics lack freshness and make it difficult to promote natural communication. Therefore, a system that allows users to quickly and easily obtain new conversation starters was needed.

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

[0705] In this invention, the server includes a means for maintaining a topic database and loading it into memory when the server starts up, a means including an algorithm for receiving a topic generation request from a user and randomly selecting one topic from the database, and a means for converting the selected topic into JSON format and sending it to a terminal, thereby enabling users to quickly and easily obtain new conversation starters.

[0706] A "topic database" is a database for storing multiple topics that serve as conversation starters.

[0707] "Loading into memory" means reading the contents of the database into the main memory device for temporary storage at startup.

[0708] A "topic creation request" is an action in which a user requests the server to create a new topic via a terminal.

[0709] A "random selection algorithm" is a computational method for randomly selecting one of the topics in a topic database.

[0710] "JSON format" is an abbreviation for JavaScript Object Notation, and is a data format that structures data in text format and makes it exchangeable.

[0711] A "terminal" is an electronic device such as a computer or smartphone that is operated by a user.

[0712] A "response" is response data sent from a server to a terminal.

[0713] A "user" is a person who operates the system to send topic creation requests and review the created topics.

[0714] An "interface" is a screen or operating means for displaying topics to a user on a terminal.

[0715] A specific embodiment of the system of the present invention, which generates and displays random topics for users to use as conversation starters, is described below.

[0716] Server Operation

[0717] The server maintains a topic database. When the server starts, it first loads this topic database into memory. This database stores multiple topics that can serve as conversation starters. When the server receives a topic generation request from a user, it randomly selects one topic from the database. The selected topic is converted into JSON format and sent to the terminal. Server processing can be achieved, for example, by using Python's random.choice function.

[0718] Device behavior

[0719] The terminal is a device operated by the user. When the user launches a dedicated application and clicks the "Create a new topic" button, the terminal sends an HTTP request to the server. This request is a request to create a topic. When the terminal receives a response from the server, it parses the received JSON data and extracts the topic text. The extracted text is displayed to the user. The display interface of the terminal is realized using, for example, HTML and JavaScript.

[0720] User operations

[0721] Users simply launch the application on their device and click a button to generate a new topic, which they will receive as a conversation starter, allowing them to easily start a conversation and communicate naturally.

[0722] Examples and behavior

[0723] For example, the topic database contains topics such as "What language have you written recently?" and "What is your favorite food?" When a user clicks the "Generate a new topic" button, the device sends a request to the server, which randomly selects the topic "What is your favorite food?" and sends it to the device. The device then displays it on the screen so that the user can check it.

[0724] Examples of prompt statements

[0725] Examples of prompts for a generative AI model might include:

[0726] "When a user clicks the 'Generate a new topic' button on their device, how do I have the server randomly select a topic and send it to the device?"

[0727] "Please tell me how the server selects a random topic and sends it to the device."

[0728] In this way, by having the roles of the server, terminal, and user work in cooperation with each other, the user can quickly and easily get a conversation start. The present invention contributes to smoother conversation and promotion of communication.

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

[0730] Step 1: Start the server

[0731] When the server starts, it loads the topic database into memory. The server reads the topic database file from local or remote storage and stores it in memory (e.g., RAM), allowing the server to quickly access all the topics in the topic database.

[0732] Input: topic database file

[0733] Output: Topic database loaded in memory

[0734] Step 2: User clicks a button

[0735] The user launches a dedicated application and clicks the "Create a new topic" button, which sends a creation request from the device to the server. The request is usually executed as an HTTP POST request.

[0736] Input: User clicks a button

[0737] Output: HTTP POST request to the server

[0738] Step 3: Receiving the request on the server

[0739] The server receives a request to create a topic from a user. The server parses the HTTP request and verifies that the request is for creating a topic.

[0740] Input: HTTP POST request

[0741] Output: Recognition of topic creation request

[0742] Step 4: Random Topic Selection

[0743] The server retrieves all topics in the topic database and uses a random algorithm (e.g., Python's random.choice function) to select one topic, which is later converted to JSON format.

[0744] Input: Topic database

[0745] Output: Randomly chosen topics

[0746] Step 5: Converting Topics to JSON Format

[0747] The server converts the selected topics into JSON format, for example using the Python json.dumps function.

[0748] Input: A randomly selected topic

[0749] Output: Topic data in JSON format

[0750] Step 6: Submit to Topic

[0751] The server converts the topic into JSON format and sends it to the terminal as an HTTP response, which also includes an HTTP status code and header information.

[0752] Input: JSON formatted topic data

[0753] Output: HTTP response to the device

[0754] Step 7: Receiving and Parsing the Response

[0755] The device receives the HTTP response from the server and parses the response using the JavaScript JSON.parse function or similar.

[0756] Input: HTTP response

[0757] Output: Parsed topic data

[0758] Step 8: Viewing Topics

[0759] The device displays the parsed topic data to the user, using the device's interface (e.g., HTML elements or UI components of a mobile app).

[0760] Input: Parsed topic data

[0761] Output: A user-visible topic display

[0762] In this way, random topics are provided to users and can be used as conversation starters.

[0763] (Application example 1)

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

[0765] Conventional systems have difficulty not only generating and displaying topics that allow users to naturally start conversations, but also providing appropriate topics according to specific contexts and purposes. Furthermore, while effective customer support is required in virtual stores, existing methods are sometimes unable to adequately address this need. This has led to a demand for improved user experience and customer satisfaction.

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

[0767] In this invention, the server includes means for having a database for generating random topics, terminal means for sending topic generation requests, means for sending randomly selected topics to the terminal means and displaying the received topics, and means for using a generative AI model to generate topics that can be used as conversation starters, thereby enabling users to provide appropriate topics for specific contexts in customer support within a virtual store, rather than simply receiving random topics.

[0768] "Server means" refers to a device that has a database for generating random topics, receives a topic generation request, and has the function of sending a randomly selected topic to a terminal means, or software that implements that function.

[0769] The "terminal means" is a device that is operated by a user to send a topic generation request to the server means, and receives and displays the topic sent from the server, or software that implements the function thereof.

[0770] A "generative AI model" is an artificial intelligence algorithm or system that generates topics that can be used as conversation starters in a given context.

[0771] A "prompt sentence" is text data that is input into a generative AI model to generate an appropriate topic.

[0772] A "topic database" is a database that stores multiple topics and is used by the server means.

[0773] The following describes in detail the mode for carrying out the present invention. The system of the present invention supports users in starting conversations naturally by generating and displaying random topics. Specific embodiments will be described below.

[0774] Server Operation

[0775] The server maintains a topic database, which stores a large number of topics. When the server starts up, it first loads this topic database into memory. When it receives a topic generation request from a user, the server randomly selects a topic from the database. At this time, it uses a generative AI model to generate a prompt sentence to generate a topic appropriate for the specific context and purpose. The selected topic is sent to the terminal in JSON format.

[0776] For example, the server loads a database with topics such as "What is your favorite product these days?" and "Which product are you interested in?", then randomly selects "Which product are you interested in?", and this selected topic is sent to the device.

[0777] Device behavior

[0778] The terminal is a device operated by the user. When the user launches an application and clicks a specific button, the terminal sends a topic creation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user.

[0779] Specifically, when a user clicks the "Generate a new topic" button, the device sends a request to the server and receives the topic "Which product are you interested in?" from the server. The device displays this on the screen so that the user can check it.

[0780] User operations

[0781] Users simply launch the application on their device and click a button to create a new topic, which they will then receive as a conversation starter, allowing them to easily start a conversation and communicate naturally.

[0782] For example, consider a case where a user visits a virtual store and uses a customer support app. When the user clicks the "Generate a new topic" button, the device sends a request to the server, and the server randomly selects a topic, such as "Which product are you interested in?". The user can then start a conversation with the virtual assistant based on this topic.

[0783] Hardware and software used

[0784] Server: A powerful computer or cloud instance

[0785] Devices: smartphones, tablets, head-mounted displays

[0786] Software: Flask (a Python web framework), generative AI models (e.g., GPT-3)

[0787] Examples of prompts include:

[0788] "Randomly generate topics to start a conversation with your customers. For example: What's your favorite product these days?"

[0789] By combining these elements, the system of the present invention can provide users with highly convenient conversation starters and improve the quality of customer support in virtual stores.

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

[0791] Step 1:

[0792] A user starts the application and clicks the "Create a new topic" button. This action causes the device to send a topic creation request to the server. The input is the user's button click, and the output is an HTTP request that sends a topic creation request to the server.

[0793] Step 2:

[0794] When the server receives a topic generation request, it loads the topic database into memory. The input is the topic generation request, and the output is the loading of the topic database. The server internally generates a prompt using a generative AI model, and selects a topic based on this prompt.

[0795] Step 3:

[0796] The server uses a generative AI model to randomly generate topics from a topic database. Specifically, it inputs a prompt sentence into the generative AI model and obtains an appropriate topic as the output. The input is the prompt sentence and the topic database, and the output is a randomly selected topic.

[0797] Step 4:

[0798] The server converts the selected topic into JSON format and sends it to the terminal. The input is a randomly selected topic, and the output is JSON format data. The server returns this JSON data to the terminal as a response using the HTTP protocol.

[0799] Step 5:

[0800] The terminal receives a JSON-formatted response from the server and parses the data to extract the topic. The input is the received JSON data, and the output is the parsed topic. Specifically, the terminal parses the data using a JSON parser.

[0801] Step 6:

[0802] The terminal displays the extracted topics on the user interface. The input is the analyzed topic, and the output is the topic displayed on the user interface. The user can check this and use it as a conversation starter. Specifically, the topic is displayed in text format on the display.

[0803] This series of processing steps allows users to easily find suitable topics to start a conversation, enabling effective customer support, especially in scenarios such as virtual stores.

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

[0805] The system of the present invention generates and displays random topics for users to use as conversation starters, and also combines an emotion engine that recognizes the user's emotions. This system has the roles of a server, a terminal, an emotion engine, and a user, which are described below.

[0806] Server Operation

[0807] The server maintains a topic database, which stores multiple topics. When the server starts up, it first loads this topic database into memory. When it receives a topic generation request from a user, the server randomly selects one topic from the database. The selected topic is sent to the device in JSON format. It can also receive emotion data from the emotion engine and adjust the selected topic.

[0808] For example, the server loads a database with topics such as "What language have you written recently?" and "What is your favorite food?", and then randomly selects "What is your favorite food?" If the emotion engine detects that the user is excited, the server will prioritize selecting a more relaxed topic. This selected topic is then sent to the device.

[0809] Device behavior

[0810] The terminal is a device operated by the user. When the user launches the app and clicks a specific button, the terminal sends a topic generation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user. In addition, the terminal communicates with the emotion engine and sends the user's emotion data to the server.

[0811] Specifically, when a user clicks the "Generate a new topic" button, the device sends a request to the server and receives the topic "What is your favorite food?" from the server. The device displays this on the screen so that the user can confirm it. At the same time, emotion data from the emotion engine is sent to the server.

[0812] Emotion Engine Operation

[0813] The emotion engine recognizes emotions by analyzing the user's voice, facial expressions, or input data. Emotion data is acquired and analyzed in real time. This data is sent to the server via the device and used as a reference for further topic selection.

[0814] For example, if a user is smiling, the emotion engine will interpret this as a "positive emotion" and send it to the server, which can then prioritize more lively topics.

[0815] User operations

[0816] Users simply launch the application on their device and click the button to generate a new topic, which they receive as a conversation starter. This allows users to easily start a conversation and promote natural communication. Additionally, the emotion engine evaluates the user's emotional state in real time and provides the most appropriate topic based on the results.

[0817] For example, if a user starts the app before a morning meeting and clicks the "Generate a new topic" button, the device sends a request to the server, which then displays a topic that matches the user's emotion, such as "What is your favorite food?". The user can then start a conversation with their colleagues based on this topic.

[0818] In this way, the system of the present invention supports users in starting a conversation naturally by having the server, terminal, and emotion engine work together to provide random and appropriate topics to the user.

[0819] The processing flow will be explained below.

[0820] Server-side processing steps

[0821] Step 1:

[0822] The server starts and loads the topic database, which contains multiple topics, such as "What language have you written in recently?" or "What is your favorite food?"

[0823] Step 2:

[0824] The server waits for an HTTP GET request to a specific endpoint (e.g., / get_random_topic).

[0825] Step 3:

[0826] The server receives a topic creation request from a terminal. This request is for the creation of a topic.

[0827] Step 4:

[0828] The server receives the user's emotional data from the emotion engine, the emotional data including the user's current emotional state.

[0829] Step 5:

[0830] The server randomly selects a topic from the topic database using the Python function random.choice() .

[0831] Step 6:

[0832] The server adjusts the randomly selected topics by taking into account emotional data, for example, prioritizing relaxing topics if the user is feeling stressed.

[0833] Step 7:

[0834] The server sends the selected topic in JSON format to the terminal, and the response includes the selected topic.

[0835] Terminal processing steps

[0836] Step 1:

[0837] The terminal will start up and display a user interface where the user can see a "Create a new topic" button.

[0838] Step 2:

[0839] The user clicks the "Create a new topic" button. This action causes the device to send a topic creation request to the server.

[0840] Step 3:

[0841] The terminal collects the user's emotional data through an emotion engine, which includes the user's voice, facial expression, or input data.

[0842] Step 4:

[0843] The terminal transmits this emotion data to the server.

[0844] Step 5:

[0845] The terminal receives a response from the server that includes the topic.

[0846] Step 6:

[0847] The terminal analyzes the response received and extracts the topic.

[0848] Step 7:

[0849] The terminal displays the extracted topics on the user interface, allowing the user to check the displayed topics.

[0850] Emotion Engine Processing Steps

[0851] Step 1:

[0852] The emotion engine collects the user's voice, facial expressions, or input data.

[0853] Step 2:

[0854] The emotion engine analyzes the collected data and recognizes the user's emotional state.

[0855] Step 3:

[0856] The emotion data recognized by the emotion engine is sent to the server via the terminal.

[0857] User operation steps

[0858] Step 1:

[0859] The user launches the app, which prepares the device for topic generation.

[0860] Step 2:

[0861] The user clicks the "Create a new topic" button, which causes the device to send a topic creation request to the server.

[0862] Step 3:

[0863] The user checks the topic displayed on the device. For example, the topic "What is your favorite food?" is displayed.

[0864] Step 4:

[0865] Users can start conversations based on the displayed topics, which promotes natural communication.

[0866] Example 2

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

[0868] Conventional conversation starter systems provide random topics without considering the user's emotional state, making it difficult to provide a topic appropriate to the user's current emotions and situation. Furthermore, if the randomly selected topic does not match the user's preferences or emotional state, the conversation may start unnaturally. This can lead to a poor communication experience for the user.

[0869] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a processing device having data storage for generating random topics, a display device that sends a topic generation request to the processing device, a device that sends the topic randomly selected by the processing device to the display device and displays the received topic, a device that acquires emotional data from the display device and sends it to the processing device, and a device that adjusts the topic based on the emotional data from the processing device. This makes it possible to start a more natural and effective conversation by providing a topic that suits the user's emotional state.

[0870] A "processing device" is an electronic device capable of manipulating data and performing a particular function or service.

[0871] A "display device" is an electronic device that provides an interface for a user to visually confirm information.

[0872] "Data storage" is a storage device for storing information and data for long periods of time.

[0873] A "topic creation request" is an operation or message that a user sends to the server requesting the creation of a new topic.

[0874] "Random selection" is a method of selecting randomly without following any particular rule or order.

[0875] "Emotion data" is information that indicates the user's current emotional state, and is extracted from voice, facial expressions, and text data.

[0876] A "tuning device" is a device that has the ability to change or optimize the content of a selected topic based on acquired data.

[0877] This invention provides a system that generates random topics to prompt users to start a conversation and displays them to them. Furthermore, it supports more natural and effective communication by assessing the user's emotional state in real time and providing optimal topics based on that information.

[0878] Server configuration and operation

[0879] The server maintains a topic database, which stores various conversation topics. When the server starts up, the topic database is loaded into memory. When the server receives a topic generation request from a user, it randomly selects one topic from the database. This selected topic is sent to the device in JSON format. It also receives emotion data from the emotion engine and adjusts the topic selection based on that data.

[0880] For example, if the server stores topics such as "What did you do on your recent holiday?" and "What is your favorite food?" in a database, and a user sends a request, the server randomly selects the topic "What is your favorite food?" If the emotion engine evaluates the user's emotional state as "Relaxed," the server can prioritize topics such as "What did you do on your recent holiday?"

[0881] Terminal configuration and operation

[0882] The terminal is a device operated by the user, on which the user launches the application. When the user clicks the "Create a new topic" button, the terminal sends a topic creation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user. Furthermore, the terminal communicates with the emotion engine and sends the user's emotion data to the server.

[0883] For example, a user clicks the "Generate a new topic" button and receives the topic "What is your favorite food?" from the server. This topic will be displayed on the device screen, and the user can see it and start a conversation. At the same time, the device will collect the user's emotion data from the emotion engine and send it to the server in real time.

[0884] Emotion engine configuration and operation

[0885] The emotion engine analyzes the user's voice, facial expressions, and text to evaluate the user's emotional state in real time. This emotional data is sent to the server via the device and used as reference information for the server to select topics.

[0886] For example, if a user is smiling while looking at the app, the emotion engine will interpret this as a "positive emotion" and send that data to the server, which can then choose lively topics appropriate for the user.

[0887] Examples and prompts

[0888] As a concrete example, suppose a user launches the app during their morning commute and clicks the "Generate a new topic" button. The device sends a request to the server, which returns the topic "What is your favorite travel destination?" This information is displayed on the device, allowing the user to start a conversation with people around them.

[0889] An example of a prompt is:

[0890] "If the user is excited, choose a topic that will generate a relaxed buzz."

[0891] "Choose a conversation topic that's appropriate for when the user is sad."

[0892] Examples include:

[0893] In this way, the system's server, terminal, and emotion engine work together to provide users with appropriate conversation topics and support natural communication.

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

[0895] Step 1:

[0896] When the server starts up, it loads the topic database into memory. Specifically, it reads multiple conversation topics stored in the topic database into the server's memory. At this point, the database contains topics such as "What is your favorite food?" and "What did you do on your last holiday?" The input is the topic database, and the output is the topic list loaded into memory. This allows the server to be ready to quickly select a topic at any time.

[0897] Step 2:

[0898] A user launches the app on their device and clicks the "Create a new topic" button. This causes the device to send a topic creation request to the server. The input is the user's click, and the output is a request message sent to the server. This message also includes the user ID, the current timestamp, and other information.

[0899] Step 3:

[0900] When the server receives a request, it randomly selects a topic from the topic database. Specifically, it uses the server's random selection algorithm. The input is the request message and the topic database, and the output is the randomly selected topic. During this process, the server also obtains emotion data from the emotion engine.

[0901] Step 4:

[0902] The server adjusts the selected topic as needed based on the emotional data it obtains. For example, if the emotional data indicates that the user is in a relaxed state, the server will preferentially select a relaxing topic such as "What did you do on your recent holiday?" The input is the emotional data and a randomly selected topic, and the output is the adjusted topic.

[0903] Step 5:

[0904] The server sends the adjusted topic to the terminal in JSON format. Specifically, it converts the topic data into JSON format and generates a network request to send it to the terminal. The input is the adjusted topic, and the output is JSON-formatted data. This data is sent via an HTTP request.

[0905] Step 6:

[0906] The terminal receives the JSON data from the server, parses it, and displays it to the user. Specifically, the terminal parses the received JSON data and displays the topic "What is your favorite food?" on the screen. The input is the JSON data from the server, and the output is a display of the topic that the user can check.

[0907] Step 7:

[0908] The device communicates with the emotion engine to collect the user's emotional data. The emotion engine automatically analyzes the user's voice, facial expressions, and text data to determine their emotional state. The input is the user's real-time data, and the output is the analyzed emotional data.

[0909] Step 8:

[0910] The device sends the collected emotion data to the server. The input is the emotion data obtained from the emotion engine, and the output is the data sent to the server. The server can then use this data to select a topic for the next time.

[0911] Through this process, the system provides users with natural conversation topics and utilizes emotional data to select more appropriate topics.

[0912] (Application example 2)

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

[0914] Conventional conversation support systems lack the means to provide appropriate topics for users to initiate conversations naturally and smoothly. Furthermore, because they randomly provide topics without considering the user's emotional state, users may encounter topics that are uninteresting. In particular, in brick-and-mortar stores, where direct interaction with customers is common, the lack of such a system hinders smooth customer service. To solve these issues, it is necessary for randomly generated conversation topics to adapt to the user's emotional state.

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

[0916] In this invention, the server includes information processing means having a storage device for generating random topics, terminal means for sending a topic generation request to the information processing means, means for sending the topic randomly selected by the information processing means to the terminal means and displaying the received topic, emotion analysis means for identifying an emotional state using emotion recognition means and sending emotion data to the information processing means, and means for adjusting the topic selected by the information processing means based on the emotion data. This makes it possible to provide an appropriate topic adapted to the emotional state of the user, thereby realizing a natural and smooth start to conversation.

[0917] The "information processing device means" is a device that has a memory device and algorithms for generating random topics, and selects and transmits topics in response to a topic generation request from a terminal.

[0918] The "terminal means" is a device that transmits a topic generation request to the information processing means and displays the received topic. It is used by being operated by a user.

[0919] "Storage" refers to a database for storing multiple topics and randomly selecting from the topics.

[0920] The "emotion recognition means" is a system that analyzes the user's voice, facial expression, behavior, etc. to identify the user's emotional state.

[0921] The "emotion analysis means" is a means for transmitting emotion data analyzed by the emotion recognition means to the information processing means.

[0922] A "topic creation request" is a request sent from a terminal means to an information processing device means, and refers to a request to create a new topic.

[0923] An "interactive user interface" is an interface that uses user-identified topics as conversation starters and is designed to be easy for users to operate.

[0924] The present invention relates to a random topic generation system for promoting natural conversations with customers, and in particular to a system that supports store clerks in brick-and-mortar stores in smoothly starting communication with customers.

[0925] The server has a storage device for generating random topics, and a database stores multiple topics. This storage device contains topics such as "What book have you read recently?" and "Where would you like to go on vacation?" The server transmits the randomly selected topic to the terminal using a stored algorithm. The server also has a means for adjusting the selected topic based on emotion data from the emotion recognition means.

[0926] The terminal is a device operated by a store clerk, such as a smartphone or tablet. An application is launched on the terminal, and a topic generation request is sent to the server. The topic received from the server is displayed to the store clerk via the terminal's interactive user interface. The store clerk can then start a conversation with the customer based on the displayed topic.

[0927] The emotion analysis means analyzes the conversation between the store clerk and the customer, as well as the customer's facial expressions and voice in real time to obtain emotional data. For example, it uses the camera and microphone built into a smartphone or tablet to analyze the user's facial expressions and voice. The analysis results are recognized in real time by the emotion recognition means and sent to the server. Based on this emotional data, the server can select topics that are appropriate for the customer's emotional state.

[0928] As a specific example, when a waiter holds a smartphone and clicks a button to generate a new topic, a request is sent to the server, and the topic "What is your favorite dish?" is received and displayed. If the emotion analysis means detects a relaxed expression on the customer's face, a more relaxed topic will be selected first. This allows the waiter to start a smooth conversation with the customer.

[0929] An example prompt is, "We are developing an app that allows store associates in physical stores to suggest appropriate topics to talk about when starting a conversation with a customer based on the customer's emotional state. If the customer is smiling, we suggest relaxing topics, and if the customer has a surprised expression, we suggest interesting topics. What specific topics would be appropriate?"

[0930] In this way, the present invention supports natural and effective communication by providing topics that adapt to the customer's emotional state.

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

[0932] Step 1:

[0933] A user launches the application on their device (smartphone or tablet) and clicks a button to create a new topic.

[0934] This operation causes the terminal to send a topic generation request to the server. The input is the user's button click action, and the output is the request data sent to the server.

[0935] Step 2:

[0936] When the server receives a request to generate a topic, it randomly selects a topic from a database in a storage device.

[0937] In this case, the server uses a topic selection algorithm to select one topic from multiple topics and sends the selected topic to the terminal. The input is a topic generation request, and the output is randomly selected topic data.

[0938] Step 3:

[0939] The terminal analyzes the topic data received from the server and displays it to the user through an interactive user interface.

[0940] Specifically, topics are displayed in text format on the screen and provided in a form that can be viewed by the user. The input is topic data from the server, and the output is topic information displayed on the screen.

[0941] Step 4:

[0942] As soon as the user is presented with a topic, the device uses its built-in emotion recognition means (camera and microphone) to analyze the user's facial expressions and voice.

[0943] It identifies the user's emotional state in real time and sends the data to an emotion analysis means. The input is the user's facial expression and voice data, and the output is analyzed emotional data.

[0944] Step 5:

[0945] The emotion analysis means analyzes the acquired emotion data and transmits it to the server.

[0946] Specifically, the emotion recognition model determines the user's emotional state (e.g., relaxed, excited, etc.) and sends the result as data to the server. The input is the analysis result of the user's facial expression and voice, and the output is emotional data.

[0947] Step 6:

[0948] The server selects a new appropriate topic based on the received emotion data.

[0949] Based on the data from the emotion recognition means, the topic selection algorithm recalculates the optimal topic and sends the adjusted topic back to the terminal. The input is emotion data, and the output is adjusted topic data.

[0950] Step 7:

[0951] The terminal again displays the adjusted topic received from the server to the user.

[0952] The initially displayed topic is replaced with a new topic that is adapted to the user's emotional state and presented in a user-friendly format. The input is the adjusted topic data, and the output is the new topic displayed to the user.

[0953] This series of processes allows the user to select an appropriate topic according to their emotional state, allowing them to start a conversation naturally and smoothly.

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

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

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

[0957] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[0971] The system of the present invention generates and displays random topics for users to use as conversation starters. The system has the roles of a server, a terminal, and a user, which are described below.

[0972] Server Operation

[0973] The server maintains a topic database, which stores multiple topics. When the server starts, it first loads this topic database into memory. When it receives a topic generation request from a user, the server randomly selects one topic from the database. The selected topic is sent to the terminal in JSON format.

[0974] As a concrete example, suppose the server loads a database with topics such as "What language have you written recently?" and "What is your favorite food?", and then randomly selects "What is your favorite food?" This selected topic is sent to the device.

[0975] Device behavior

[0976] The terminal is a device operated by the user. When the user launches the app and clicks a specific button, the terminal sends a topic creation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user.

[0977] Specifically, when a user clicks the "Generate a new topic" button, the device sends a request to the server and receives the topic "What is your favorite food?" from the server. The device displays this on the screen so that the user can check it.

[0978] User operations

[0979] Users simply launch the application on their device and click a button to generate a new topic, which they will receive as a conversation starter, allowing them to easily start a conversation and communicate naturally.

[0980] For example, if a user launches the app before a morning meeting and clicks the "Generate a new topic" button, the device sends a request to the server, which then displays a randomly selected topic, such as "What's your favorite food?", which the user can use to start a conversation with their colleagues.

[0981] In this way, the system of the present invention provides users with random topics through communication between the server and the terminal, helping them to start conversations naturally. The server's topic database, random selection algorithm, and terminal interface work together to create a system that is highly convenient for users.

[0982] The processing flow will be explained below.

[0983] Server-side processing steps

[0984] Step 1:

[0985] The server starts and loads the topic database, which contains multiple topics. For example, the database might contain questions like "What language have you written in recently?" or "What is your favorite food?"

[0986] Step 2:

[0987] The server waits for an HTTP GET request to a specific endpoint (e.g., / get_random_topic).

[0988] Step 3:

[0989] The server receives a topic creation request from a terminal. This request is for the creation of a topic.

[0990] Step 4:

[0991] The server randomly selects a topic from the topic database using the Python function random.choice() .

[0992] Step 5:

[0993] The server sends the selected topic in JSON format to the terminal, and the response includes the selected topic.

[0994] Terminal processing steps

[0995] Step 1:

[0996] The terminal will start up and display a user interface where the user can see a "Create a new topic" button.

[0997] Step 2:

[0998] The user clicks the "Create a new topic" button. This action causes the device to send a topic creation request to the server.

[0999] Step 3:

[1000] The server receives the request sent by the terminal and receives a response containing a randomly selected topic from the server.

[1001] Step 4:

[1002] The device parses the response from the server and extracts the topic from the JSON data included in the response.

[1003] Step 5:

[1004] The terminal displays the extracted topics on the user interface, allowing the user to check the displayed topics.

[1005] User operation steps

[1006] Step 1:

[1007] The user launches the app, which prepares the device for topic generation.

[1008] Step 2:

[1009] The user clicks the "Create a new topic" button, which causes the device to send a topic creation request to the server.

[1010] Step 3:

[1011] The user checks the topic displayed on the device. For example, the topic "What is your favorite food?" is displayed.

[1012] Step 4:

[1013] Users can start conversations based on the displayed topics, which promotes natural communication.

[1014] Example 1

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

[1016] Conventional methods for starting conversations require users to come up with topics themselves, which is time-consuming and inefficient. Furthermore, systems that use fixed topics lack freshness and make it difficult to promote natural communication. Therefore, a system that allows users to quickly and easily obtain new conversation starters was needed.

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

[1018] In this invention, the server includes a means for maintaining a topic database and loading it into memory when the server starts up, a means including an algorithm for receiving a topic generation request from a user and randomly selecting one topic from the database, and a means for converting the selected topic into JSON format and sending it to a terminal, thereby enabling users to quickly and easily obtain new conversation starters.

[1019] A "topic database" is a database for storing multiple topics that serve as conversation starters.

[1020] "Loading into memory" means reading the contents of the database into the main memory device for temporary storage at startup.

[1021] A "topic creation request" is an action in which a user requests the server to create a new topic via a terminal.

[1022] A "random selection algorithm" is a computational method for randomly selecting one of the topics in a topic database.

[1023] "JSON format" is an abbreviation for JavaScript Object Notation, and is a data format that structures data in text format and makes it exchangeable.

[1024] A "terminal" is an electronic device such as a computer or smartphone that is operated by a user.

[1025] A "response" is response data sent from a server to a terminal.

[1026] A "user" is a person who operates the system to send topic creation requests and review the created topics.

[1027] An "interface" is a screen or operating means for displaying topics to a user on a terminal.

[1028] A specific embodiment of the system of the present invention, which generates and displays random topics for users to use as conversation starters, is described below.

[1029] Server Operation

[1030] The server maintains a topic database. When the server starts, it first loads this topic database into memory. This database stores multiple topics that can serve as conversation starters. When the server receives a topic generation request from a user, it randomly selects one topic from the database. The selected topic is converted into JSON format and sent to the terminal. Server processing can be achieved, for example, by using Python's random.choice function.

[1031] Device behavior

[1032] The terminal is a device operated by the user. When the user launches a dedicated application and clicks the "Create a new topic" button, the terminal sends an HTTP request to the server. This request is a request to create a topic. When the terminal receives a response from the server, it parses the received JSON data and extracts the topic text. The extracted text is displayed to the user. The display interface of the terminal is realized using, for example, HTML and JavaScript.

[1033] User operations

[1034] Users simply launch the application on their device and click a button to generate a new topic, which they will receive as a conversation starter, allowing them to easily start a conversation and communicate naturally.

[1035] Examples and behavior

[1036] For example, the topic database contains topics such as "What language have you written recently?" and "What is your favorite food?" When a user clicks the "Generate a new topic" button, the device sends a request to the server, which randomly selects the topic "What is your favorite food?" and sends it to the device. The device then displays it on the screen so that the user can check it.

[1037] Examples of prompt statements

[1038] Examples of prompts for a generative AI model might include:

[1039] "When a user clicks the 'Generate a new topic' button on their device, how do I have the server randomly select a topic and send it to the device?"

[1040] "Please tell me how the server selects a random topic and sends it to the device."

[1041] In this way, by having the roles of the server, terminal, and user work in cooperation with each other, the user can quickly and easily get a conversation start. The present invention contributes to smoother conversation and promotion of communication.

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

[1043] Step 1: Start the server

[1044] When the server starts, it loads the topic database into memory. The server reads the topic database file from local or remote storage and stores it in memory (e.g., RAM), allowing the server to quickly access all the topics in the topic database.

[1045] Input: topic database file

[1046] Output: Topic database loaded in memory

[1047] Step 2: User clicks a button

[1048] The user launches a dedicated application and clicks the "Create a new topic" button, which sends a creation request from the device to the server. The request is usually executed as an HTTP POST request.

[1049] Input: User clicks a button

[1050] Output: HTTP POST request to the server

[1051] Step 3: Receiving the request on the server

[1052] The server receives a request to create a topic from a user. The server parses the HTTP request and verifies that the request is for creating a topic.

[1053] Input: HTTP POST request

[1054] Output: Recognition of topic creation request

[1055] Step 4: Random Topic Selection

[1056] The server retrieves all topics in the topic database and uses a random algorithm (e.g., Python's random.choice function) to select one topic, which is later converted to JSON format.

[1057] Input: Topic database

[1058] Output: Randomly chosen topics

[1059] Step 5: Converting Topics to JSON Format

[1060] The server converts the selected topics into JSON format, for example using the Python json.dumps function.

[1061] Input: A randomly selected topic

[1062] Output: Topic data in JSON format

[1063] Step 6: Submit to Topic

[1064] The server converts the topic into JSON format and sends it to the terminal as an HTTP response, which also includes an HTTP status code and header information.

[1065] Input: JSON formatted topic data

[1066] Output: HTTP response to the device

[1067] Step 7: Receiving and Parsing the Response

[1068] The device receives the HTTP response from the server and parses the response using the JavaScript JSON.parse function or similar.

[1069] Input: HTTP response

[1070] Output: Parsed topic data

[1071] Step 8: Viewing Topics

[1072] The device displays the parsed topic data to the user, using the device's interface (e.g., HTML elements or UI components of a mobile app).

[1073] Input: Parsed topic data

[1074] Output: A user-visible topic display

[1075] In this way, random topics are provided to users and can be used as conversation starters.

[1076] (Application example 1)

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

[1078] Conventional systems have difficulty not only generating and displaying topics that allow users to naturally start conversations, but also providing appropriate topics according to specific contexts and purposes. Furthermore, while effective customer support is required in virtual stores, existing methods are sometimes unable to adequately address this need. This has led to a demand for improved user experience and customer satisfaction.

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

[1080] In this invention, the server includes means for having a database for generating random topics, terminal means for sending topic generation requests, means for sending randomly selected topics to the terminal means and displaying the received topics, and means for using a generative AI model to generate topics that can be used as conversation starters, thereby enabling users to provide appropriate topics for specific contexts in customer support within a virtual store, rather than simply receiving random topics.

[1081] "Server means" refers to a device that has a database for generating random topics, receives a topic generation request, and has the function of sending a randomly selected topic to a terminal means, or software that implements that function.

[1082] The "terminal means" is a device that is operated by a user to send a topic generation request to the server means, and receives and displays the topic sent from the server, or software that implements the function thereof.

[1083] A "generative AI model" is an artificial intelligence algorithm or system that generates topics that can be used as conversation starters in a given context.

[1084] A "prompt sentence" is text data that is input into a generative AI model to generate an appropriate topic.

[1085] A "topic database" is a database that stores multiple topics and is used by the server means.

[1086] The following describes in detail the mode for carrying out the present invention. The system of the present invention supports users in starting conversations naturally by generating and displaying random topics. Specific embodiments will be described below.

[1087] Server Operation

[1088] The server maintains a topic database, which stores a large number of topics. When the server starts up, it first loads this topic database into memory. When it receives a topic generation request from a user, the server randomly selects a topic from the database. At this time, it uses a generative AI model to generate a prompt sentence to generate a topic appropriate for the specific context and purpose. The selected topic is sent to the terminal in JSON format.

[1089] For example, the server loads a database with topics such as "What is your favorite product these days?" and "Which product are you interested in?", then randomly selects "Which product are you interested in?", and this selected topic is sent to the device.

[1090] Device behavior

[1091] The terminal is a device operated by the user. When the user launches an application and clicks a specific button, the terminal sends a topic creation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user.

[1092] Specifically, when a user clicks the "Generate a new topic" button, the device sends a request to the server and receives the topic "Which product are you interested in?" from the server. The device displays this on the screen so that the user can check it.

[1093] User operations

[1094] Users simply launch the application on their device and click a button to create a new topic, which they will then receive as a conversation starter, allowing them to easily start a conversation and communicate naturally.

[1095] For example, consider a case where a user visits a virtual store and uses a customer support app. When the user clicks the "Generate a new topic" button, the device sends a request to the server, and the server randomly selects a topic, such as "Which product are you interested in?". The user can then start a conversation with the virtual assistant based on this topic.

[1096] Hardware and software used

[1097] Server: A powerful computer or cloud instance

[1098] Devices: smartphones, tablets, head-mounted displays

[1099] Software: Flask (a Python web framework), generative AI models (e.g., GPT-3)

[1100] Examples of prompts include:

[1101] "Randomly generate topics to start a conversation with your customers. For example: What's your favorite product these days?"

[1102] By combining these elements, the system of the present invention can provide users with highly convenient conversation starters and improve the quality of customer support in virtual stores.

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

[1104] Step 1:

[1105] A user starts the application and clicks the "Create a new topic" button. This action causes the device to send a topic creation request to the server. The input is the user's button click, and the output is an HTTP request that sends a topic creation request to the server.

[1106] Step 2:

[1107] When the server receives a topic generation request, it loads the topic database into memory. The input is the topic generation request, and the output is the loading of the topic database. The server internally generates a prompt using a generative AI model, and selects a topic based on this prompt.

[1108] Step 3:

[1109] The server uses a generative AI model to randomly generate topics from a topic database. Specifically, it inputs a prompt sentence into the generative AI model and obtains an appropriate topic as the output. The input is the prompt sentence and the topic database, and the output is a randomly selected topic.

[1110] Step 4:

[1111] The server converts the selected topic into JSON format and sends it to the terminal. The input is a randomly selected topic, and the output is JSON format data. The server returns this JSON data to the terminal as a response using the HTTP protocol.

[1112] Step 5:

[1113] The terminal receives a JSON-formatted response from the server and parses the data to extract the topic. The input is the received JSON data, and the output is the parsed topic. Specifically, the terminal parses the data using a JSON parser.

[1114] Step 6:

[1115] The terminal displays the extracted topics on the user interface. The input is the analyzed topic, and the output is the topic displayed on the user interface. The user can check this and use it as a conversation starter. Specifically, the topic is displayed in text format on the display.

[1116] This series of processing steps allows users to easily find suitable topics to start a conversation, enabling effective customer support, especially in scenarios such as virtual stores.

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

[1118] The system of the present invention generates and displays random topics for users to use as conversation starters, and also combines an emotion engine that recognizes the user's emotions. This system has the roles of a server, a terminal, an emotion engine, and a user, which are described below.

[1119] Server Operation

[1120] The server maintains a topic database, which stores multiple topics. When the server starts up, it first loads this topic database into memory. When it receives a topic generation request from a user, the server randomly selects one topic from the database. The selected topic is sent to the device in JSON format. It can also receive emotion data from the emotion engine and adjust the selected topic.

[1121] For example, the server loads a database with topics such as "What language have you written recently?" and "What is your favorite food?", and then randomly selects "What is your favorite food?" If the emotion engine detects that the user is excited, the server will prioritize selecting a more relaxed topic. This selected topic is then sent to the device.

[1122] Device behavior

[1123] The terminal is a device operated by the user. When the user launches the app and clicks a specific button, the terminal sends a topic generation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user. In addition, the terminal communicates with the emotion engine and sends the user's emotion data to the server.

[1124] Specifically, when a user clicks the "Generate a new topic" button, the device sends a request to the server and receives the topic "What is your favorite food?" from the server. The device displays this on the screen so that the user can confirm it. At the same time, emotion data from the emotion engine is sent to the server.

[1125] Emotion Engine Operation

[1126] The emotion engine recognizes emotions by analyzing the user's voice, facial expressions, or input data. Emotion data is acquired and analyzed in real time. This data is sent to the server via the device and used as a reference for further topic selection.

[1127] For example, if a user is smiling, the emotion engine will interpret this as a "positive emotion" and send it to the server, which can then prioritize more lively topics.

[1128] User operations

[1129] Users simply launch the application on their device and click the button to generate a new topic, which they receive as a conversation starter. This allows users to easily start a conversation and promote natural communication. Additionally, the emotion engine evaluates the user's emotional state in real time and provides the most appropriate topic based on the results.

[1130] For example, if a user starts the app before a morning meeting and clicks the "Generate a new topic" button, the device sends a request to the server, which then displays a topic that matches the user's emotion, such as "What is your favorite food?". The user can then start a conversation with their colleagues based on this topic.

[1131] In this way, the system of the present invention supports users in starting a conversation naturally by having the server, terminal, and emotion engine work together to provide random and appropriate topics to the user.

[1132] The processing flow will be explained below.

[1133] Server-side processing steps

[1134] Step 1:

[1135] The server starts and loads the topic database, which contains multiple topics, such as "What language have you written in recently?" or "What is your favorite food?"

[1136] Step 2:

[1137] The server waits for an HTTP GET request to a specific endpoint (e.g., / get_random_topic).

[1138] Step 3:

[1139] The server receives a topic creation request from a terminal. This request is for the creation of a topic.

[1140] Step 4:

[1141] The server receives the user's emotional data from the emotion engine, the emotional data including the user's current emotional state.

[1142] Step 5:

[1143] The server randomly selects a topic from the topic database using the Python function random.choice() .

[1144] Step 6:

[1145] The server adjusts the randomly selected topics by taking into account emotional data, for example, prioritizing relaxing topics if the user is feeling stressed.

[1146] Step 7:

[1147] The server sends the selected topic in JSON format to the terminal, and the response includes the selected topic.

[1148] Terminal processing steps

[1149] Step 1:

[1150] The terminal will start up and display a user interface where the user can see a "Create a new topic" button.

[1151] Step 2:

[1152] The user clicks the "Create a new topic" button. This action causes the device to send a topic creation request to the server.

[1153] Step 3:

[1154] The terminal collects the user's emotional data through an emotion engine, which includes the user's voice, facial expression, or input data.

[1155] Step 4:

[1156] The terminal transmits this emotion data to the server.

[1157] Step 5:

[1158] The terminal receives a response from the server that includes the topic.

[1159] Step 6:

[1160] The terminal analyzes the response received and extracts the topic.

[1161] Step 7:

[1162] The terminal displays the extracted topics on the user interface, allowing the user to check the displayed topics.

[1163] Emotion Engine Processing Steps

[1164] Step 1:

[1165] The emotion engine collects the user's voice, facial expressions, or input data.

[1166] Step 2:

[1167] The emotion engine analyzes the collected data and recognizes the user's emotional state.

[1168] Step 3:

[1169] The emotion data recognized by the emotion engine is sent to the server via the terminal.

[1170] User operation steps

[1171] Step 1:

[1172] The user launches the app, which prepares the device for topic generation.

[1173] Step 2:

[1174] The user clicks the "Create a new topic" button, which causes the device to send a topic creation request to the server.

[1175] Step 3:

[1176] The user checks the topic displayed on the device. For example, the topic "What is your favorite food?" is displayed.

[1177] Step 4:

[1178] Users can start conversations based on the displayed topics, which promotes natural communication.

[1179] Example 2

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

[1181] Conventional conversation starter systems provide random topics without considering the user's emotional state, making it difficult to provide a topic appropriate to the user's current emotions and situation. Furthermore, if the randomly selected topic does not match the user's preferences or emotional state, the conversation may start unnaturally. This can lead to a poor communication experience for the user.

[1182] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a processing device having data storage for generating random topics, a display device that sends a topic generation request to the processing device, a device that sends the topic randomly selected by the processing device to the display device and displays the received topic, a device that acquires emotional data from the display device and sends it to the processing device, and a device that adjusts the topic based on the emotional data from the processing device. This makes it possible to start a more natural and effective conversation by providing a topic that suits the user's emotional state.

[1183] A "processing device" is an electronic device capable of manipulating data and performing a particular function or service.

[1184] A "display device" is an electronic device that provides an interface for a user to visually confirm information.

[1185] "Data storage" is a storage device for storing information and data for long periods of time.

[1186] A "topic creation request" is an operation or message that a user sends to the server requesting the creation of a new topic.

[1187] "Random selection" is a method of selecting randomly without following any particular rule or order.

[1188] "Emotion data" is information that indicates the user's current emotional state, and is extracted from voice, facial expressions, and text data.

[1189] A "tuning device" is a device that has the ability to change or optimize the content of a selected topic based on acquired data.

[1190] This invention provides a system that generates random topics to prompt users to start a conversation and displays them to them. Furthermore, it supports more natural and effective communication by assessing the user's emotional state in real time and providing optimal topics based on that information.

[1191] Server configuration and operation

[1192] The server maintains a topic database, which stores various conversation topics. When the server starts up, the topic database is loaded into memory. When the server receives a topic generation request from a user, it randomly selects one topic from the database. This selected topic is sent to the device in JSON format. It also receives emotion data from the emotion engine and adjusts the topic selection based on that data.

[1193] For example, if the server stores topics such as "What did you do on your recent holiday?" and "What is your favorite food?" in a database, and a user sends a request, the server randomly selects the topic "What is your favorite food?" If the emotion engine evaluates the user's emotional state as "Relaxed," the server can prioritize topics such as "What did you do on your recent holiday?"

[1194] Terminal configuration and operation

[1195] The terminal is a device operated by the user, on which the user launches the application. When the user clicks the "Create a new topic" button, the terminal sends a topic creation request to the server. Upon receiving a response from the server, the terminal analyzes the data and has an interface that displays the topic to the user. Furthermore, the terminal communicates with the emotion engine and sends the user's emotion data to the server.

[1196] For example, a user clicks the "Generate a new topic" button and receives the topic "What is your favorite food?" from the server. This topic will be displayed on the device screen, and the user can see it and start a conversation. At the same time, the device will collect the user's emotion data from the emotion engine and send it to the server in real time.

[1197] Emotion engine configuration and operation

[1198] The emotion engine analyzes the user's voice, facial expressions, and text to evaluate the user's emotional state in real time. This emotional data is sent to the server via the device and used as reference information for the server to select topics.

[1199] For example, if a user is smiling while looking at the app, the emotion engine will interpret this as a "positive emotion" and send that data to the server, which can then choose lively topics appropriate for the user.

[1200] Examples and prompts

[1201] As a concrete example, suppose a user launches the app during their morning commute and clicks the "Generate a new topic" button. The device sends a request to the server, which returns the topic "What is your favorite travel destination?" This information is displayed on the device, allowing the user to start a conversation with people around them.

[1202] An example of a prompt is:

[1203] "If the user is excited, choose a topic that will generate a relaxed buzz."

[1204] "Choose a conversation topic that's appropriate for when the user is sad."

[1205] Examples include:

[1206] In this way, the system's server, terminal, and emotion engine work together to provide users with appropriate conversation topics and support natural communication.

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

[1208] Step 1:

[1209] When the server starts up, it loads the topic database into memory. Specifically, it reads multiple conversation topics stored in the topic database into the server's memory. At this point, the database contains topics such as "What is your favorite food?" and "What did you do on your last holiday?" The input is the topic database, and the output is the topic list loaded into memory. This allows the server to be ready to quickly select a topic at any time.

[1210] Step 2:

[1211] A user launches the app on their device and clicks the "Create a new topic" button. This causes the device to send a topic creation request to the server. The input is the user's click, and the output is a request message sent to the server. This message also includes the user ID, the current timestamp, and other information.

[1212] Step 3:

[1213] When the server receives a request, it randomly selects a topic from the topic database. Specifically, it uses the server's random selection algorithm. The input is the request message and the topic database, and the output is the randomly selected topic. During this process, the server also obtains emotion data from the emotion engine.

[1214] Step 4:

[1215] The server adjusts the selected topic as needed based on the emotional data it obtains. For example, if the emotional data indicates that the user is in a relaxed state, the server will preferentially select a relaxing topic such as "What did you do on your recent holiday?" The input is the emotional data and a randomly selected topic, and the output is the adjusted topic.

[1216] Step 5:

[1217] The server sends the adjusted topic to the terminal in JSON format. Specifically, it converts the topic data into JSON format and generates a network request to send it to the terminal. The input is the adjusted topic, and the output is JSON-formatted data. This data is sent via an HTTP request.

[1218] Step 6:

[1219] The terminal receives the JSON data from the server, parses it, and displays it to the user. Specifically, the terminal parses the received JSON data and displays the topic "What is your favorite food?" on the screen. The input is the JSON data from the server, and the output is a display of the topic that the user can check.

[1220] Step 7:

[1221] The device communicates with the emotion engine to collect the user's emotional data. The emotion engine automatically analyzes the user's voice, facial expressions, and text data to determine their emotional state. The input is the user's real-time data, and the output is the analyzed emotional data.

[1222] Step 8:

[1223] The device sends the collected emotion data to the server. The input is the emotion data obtained from the emotion engine, and the output is the data sent to the server. The server can then use this data to select a topic for the next time.

[1224] Through this process, the system provides users with natural conversation topics and utilizes emotional data to select more appropriate topics.

[1225] (Application example 2)

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

[1227] Conventional conversation support systems lack the means to provide appropriate topics for users to initiate conversations naturally and smoothly. Furthermore, because they randomly provide topics without considering the user's emotional state, users may encounter topics that are uninteresting. In particular, in brick-and-mortar stores, where direct interaction with customers is common, the lack of such a system hinders smooth customer service. To solve these issues, it is necessary for randomly generated conversation topics to adapt to the user's emotional state.

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

[1229] In this invention, the server includes information processing means having a storage device for generating random topics, terminal means for sending a topic generation request to the information processing means, means for sending the topic randomly selected by the information processing means to the terminal means and displaying the received topic, emotion analysis means for identifying an emotional state using emotion recognition means and sending emotion data to the information processing means, and means for adjusting the topic selected by the information processing means based on the emotion data. This makes it possible to provide an appropriate topic adapted to the emotional state of the user, thereby realizing a natural and smooth start to conversation.

[1230] The "information processing device means" is a device that has a memory device and algorithms for generating random topics, and selects and transmits topics in response to a topic generation request from a terminal.

[1231] The "terminal means" is a device that transmits a topic generation request to the information processing means and displays the received topic. It is used by being operated by a user.

[1232] "Storage" refers to a database for storing multiple topics and randomly selecting from the topics.

[1233] The "emotion recognition means" is a system that analyzes the user's voice, facial expression, behavior, etc. to identify the user's emotional state.

[1234] The "emotion analysis means" is a means for transmitting emotion data analyzed by the emotion recognition means to the information processing means.

[1235] A "topic creation request" is a request sent from a terminal means to an information processing device means, and refers to a request to create a new topic.

[1236] An "interactive user interface" is an interface that uses user-identified topics as conversation starters and is designed to be easy for users to operate.

[1237] The present invention relates to a random topic generation system for promoting natural conversations with customers, and in particular to a system that supports store clerks in brick-and-mortar stores in smoothly starting communication with customers.

[1238] The server has a storage device for generating random topics, and a database stores multiple topics. This storage device contains topics such as "What book have you read recently?" and "Where would you like to go on vacation?" The server transmits the randomly selected topic to the terminal using a stored algorithm. The server also has a means for adjusting the selected topic based on emotion data from the emotion recognition means.

[1239] The terminal is a device operated by a store clerk, such as a smartphone or tablet. An application is launched on the terminal, and a topic generation request is sent to the server. The topic received from the server is displayed to the store clerk via the terminal's interactive user interface. The store clerk can then start a conversation with the customer based on the displayed topic.

[1240] The emotion analysis means analyzes the conversation between the store clerk and the customer, as well as the customer's facial expressions and voice in real time to obtain emotional data. For example, it uses the camera and microphone built into a smartphone or tablet to analyze the user's facial expressions and voice. The analysis results are recognized in real time by the emotion recognition means and sent to the server. Based on this emotional data, the server can select topics that are appropriate for the customer's emotional state.

[1241] As a specific example, when a waiter holds a smartphone and clicks a button to generate a new topic, a request is sent to the server, and the topic "What is your favorite dish?" is received and displayed. If the emotion analysis means detects a relaxed expression on the customer's face, a more relaxed topic will be selected first. This allows the waiter to start a smooth conversation with the customer.

[1242] An example prompt is, "We are developing an app that allows store associates in physical stores to suggest appropriate topics to talk about when starting a conversation with a customer based on the customer's emotional state. If the customer is smiling, we suggest relaxing topics, and if the customer has a surprised expression, we suggest interesting topics. What specific topics would be appropriate?"

[1243] In this way, the present invention supports natural and effective communication by providing topics that adapt to the customer's emotional state.

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

[1245] Step 1:

[1246] A user launches the application on their device (smartphone or tablet) and clicks a button to create a new topic.

[1247] This operation causes the terminal to send a topic generation request to the server. The input is the user's button click action, and the output is the request data sent to the server.

[1248] Step 2:

[1249] When the server receives a request to generate a topic, it randomly selects a topic from a database in a storage device.

[1250] In this case, the server uses a topic selection algorithm to select one topic from multiple topics and sends the selected topic to the terminal. The input is a topic generation request, and the output is randomly selected topic data.

[1251] Step 3:

[1252] The terminal analyzes the topic data received from the server and displays it to the user through an interactive user interface.

[1253] Specifically, topics are displayed in text format on the screen and provided in a form that can be viewed by the user. The input is topic data from the server, and the output is topic information displayed on the screen.

[1254] Step 4:

[1255] As soon as the user is presented with a topic, the device uses its built-in emotion recognition means (camera and microphone) to analyze the user's facial expressions and voice.

[1256] It identifies the user's emotional state in real time and sends the data to an emotion analysis means. The input is the user's facial expression and voice data, and the output is analyzed emotional data.

[1257] Step 5:

[1258] The emotion analysis means analyzes the acquired emotion data and transmits it to the server.

[1259] Specifically, the emotion recognition model determines the user's emotional state (e.g., relaxed, excited, etc.) and sends the result as data to the server. The input is the analysis result of the user's facial expression and voice, and the output is emotional data.

[1260] Step 6:

[1261] The server selects a new appropriate topic based on the received emotion data.

[1262] Based on the data from the emotion recognition means, the topic selection algorithm recalculates the optimal topic and sends the adjusted topic back to the terminal. The input is emotion data, and the output is adjusted topic data.

[1263] Step 7:

[1264] The terminal again displays the adjusted topic received from the server to the user.

[1265] The initially displayed topic is replaced with a new topic that is adapted to the user's emotional state and presented in a user-friendly format. The input is the adjusted topic data, and the output is the new topic displayed to the user.

[1266] This series of processes allows the user to select an appropriate topic according to their emotional state, allowing them to start a conversation naturally and smoothly.

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

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

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

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

[1271] FIG. 9 illustrates 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 behaviors 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[1288] The following is further disclosed regarding the above embodiment.

[1289] (Claim 1)

[1290] a server means having a database for generating random topics;

[1291] a terminal means for transmitting a topic creation request to the server means;

[1292] means for transmitting a topic randomly selected by said server means to said terminal means and displaying the received topic;

[1293] A system including:

[1294] (Claim 2)

[1295] The system of claim 1, further comprising an algorithm for randomly selecting a topic from the plurality of topics stored in the database.

[1296] (Claim 3)

[1297] 2. The system according to claim 1, further comprising an interface that allows a user to check the topics displayed by the terminal means and use them as conversation starters.

[1298] "Example 1"

[1299] (Claim 1)

[1300] A means of maintaining a topic database and loading it into memory at server startup;

[1301] a means for receiving a topic generation request from a user and including an algorithm for randomly selecting a topic from within a database;

[1302] A means for converting the selected topic into JSON format and sending it to the terminal;

[1303] A means for sending a topic creation request to a server in a terminal operated by a user;

[1304] a means for receiving a response from the server, analyzing the received topic, and displaying it to the user;

[1305] A system including:

[1306] (Claim 2)

[1307] The system of claim 1, comprising an algorithm for randomly selecting a topic from a plurality of topics stored in a database.

[1308] (Claim 3)

[1309] 2. The system according to claim 1, further comprising an interface that allows a user to check topics displayed by the terminal and use them as conversation starters.

[1310] "Application Example 1"

[1311] (Claim 1)

[1312] a server means having a database for generating random topics;

[1313] a terminal means for transmitting a topic creation request to the server means;

[1314] means for transmitting a topic randomly selected by said server means to said terminal means and displaying the received topic;

[1315] A means for using a generative AI model to generate topics that can be used as conversation starters;

[1316] A system including:

[1317] (Claim 2)

[1318] The system of claim 1 further comprises an algorithm for randomly selecting a topic from a plurality of topics stored in the database, a means for generating a prompt sentence based on a generative AI model, and a means for displaying a topic according to the prompt sentence.

[1319] (Claim 3)

[1320] 2. The system according to claim 1, further comprising an interface that allows a user to check the topics displayed by the terminal means and use them as conversation starters.

[1321] "Example 2: Combining Emotion Engines"

[1322] (Claim 1)

[1323] a processing unit having data storage for generating random topics;

[1324] a display device that transmits a topic generation request to the processing device;

[1325] a device for transmitting a randomly selected topic from the processing device to the display device and displaying the received topic;

[1326] a device for the display device to acquire emotion data and transmit it to the processing device;

[1327] a device for adjusting a topic based on the emotion data;

[1328] A system including:

[1329] (Claim 2)

[1330] The system of claim 1, further comprising an algorithm for randomly selecting a topic from the plurality of topics stored in the data storage.

[1331] (Claim 3)

[1332] 2. The system according to claim 1, further comprising an interface that allows a user to check the topics displayed by the display device and use them as a starting point for a conversation.

[1333] "Application example 2 when combining emotion engines"

[1334] (Claim 1)

[1335] an information processing device having a storage device for generating random topics;

[1336] a terminal means for transmitting a topic generation request to the information processing device means;

[1337] means for transmitting a topic randomly selected by said information processing device means to said terminal means and displaying the received topic;

[1338] emotion analysis means for identifying an emotional state using emotion recognition means and transmitting emotion data to said information processing means;

[1339] means for adjusting a topic selected by said information processing device means based on said emotion data;

[1340] A system including:

[1341] (Claim 2)

[1342] 2. The system according to claim 1, further comprising: means for randomly selecting a topic from a plurality of topics stored in said storage device; and an algorithm for adaptively changing the topic selection based on said emotion data.

[1343] (Claim 3)

[1344] 2. The system according to claim 1, further comprising an interactive user interface that allows a user to check the topics displayed by the terminal means and use them as a starting point for a conversation. [Explanation of symbols]

[1345] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. a server means having a database for generating random topics; a terminal means for transmitting a topic creation request to the server means; means for transmitting a topic randomly selected by said server means to said terminal means and displaying the received topic; A system including:

2. The system of claim 1 further comprising an algorithm for randomly selecting a topic from the plurality of topics stored in the database.

3. 2. The system according to claim 1, further comprising an interface that allows a user to confirm the topics displayed by said terminal means and use them as conversation starters.

Images