system

Abstract

Provide a system. [Solution] means for receiving emotion data input by a user; a means for storing the received emotion data in a database; means for randomly selecting a message to periodically provide a reflection prompt to the user; means for displaying the provided message to the user; A system including:

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 society, many people face stress and mental health issues. These issues have a negative impact on daily life and, in some cases, can lead to serious mental illness. Traditional mental care approaches rely mainly on face-to-face counseling by professionals, but accessibility is limited. Furthermore, there is a lack of systems for recording individual emotions on a daily basis and providing appropriate advice and feedback based on that information, making effective self-mental care difficult. [Means for solving the problem]

[0005] To solve the above problems, the present invention provides the following means: a system including means for receiving emotional data input by a user, means for storing the received emotional data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, and means for displaying the provided message to the user. This allows the user to easily record their emotions and become aware of self-understanding and positive experiences through weekly reflection. This enables efficient self-mental care and helps alleviate mental health problems.

[0006] A "user" is an entity that uses the system to input emotions and receive reflection prompts.

[0007] "Emotion data" refers to data that includes the emotion entered by the user and associated information (e.g., the date and time of recording).

[0008] A "database" is a data storage device for storing and managing emotion data received from users.

[0009] "Reflection prompts" are messages provided to users to encourage self-reflection and may include content that makes them aware of their own positive experiences.

[0010] A "message" is text information containing specific questions or advice provided as a reflection prompt.

[0011] "Means" refers to a method or device for achieving a particular function or operation, and is used herein to receive data, store data, select and display messages within the system. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0020] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0033] The "Self-Mental Care Coach" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. Specific embodiments of this system will be described below.

[0034] User emotion record

[0035] 1. Display the emotion input screen

[0036] The device starts the application and displays an interface (emotion input screen) for the user to input emotions. The user inputs their current emotion (e.g., "happy," "sad," etc.) in a text field.

[0037] 2. Sending Emotional Data

[0038] After entering their emotion, the user taps the "Send" button, which causes the device to request the server to send the emotion data they entered. At the same time, the current date and time are also attached to the request.

[0039] 3. Emotional Data Storage

[0040] The server processes the emotion data received from the device and records it in the user's emotion log (database). For example, the emotion data is saved in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[0041] 4. Recording completion notification

[0042] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions recorded."

[0043] Providing Reflection Messages

[0044] 1. Displaying the reflection screen

[0045] The device displays the reflection screen to the user who selects "Weekly Reflection" from the application menu. The user taps the "Receive Prompt" button.

[0046] 2. Request a Reflection Prompt

[0047] The terminal transmits a request for a reflection prompt from the user to the server.

[0048] 3. Select a reflection prompt

[0049] When the server receives a request, it randomly selects one message from the list of reflected messages, for example a prompt such as "What was the happiest moment of your week?"

[0050] 4. Sending a Reflection Prompt

[0051] The server sends the selected reflection prompt to the terminal, which displays the message to the user.

[0052] Specific examples

[0053] Examples of emotion recording

[0054] The user opens the application and enters their current emotion, "Happy." When they tap the "Send" button, the device sends the emotion data "Happy" and the current date and time to the server. The server adds the received data to the user's emotion log and notifies them that the recording was successful. The device displays "Emotion recorded."

[0055] Specific examples of reflection messages

[0056] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[0057] This allows users to record their daily emotions and deepen self-understanding through weekly reflection, which is expected to enable efficient self-mental care and contribute to improving mental health.

[0058] The processing flow will be explained below.

[0059] Processing emotion records

[0060] Step 1:

[0061] The terminal displays a screen for the user to input an emotion, and the user inputs the current emotion in a text field on the emotion input screen.

[0062] Step 2:

[0063] After inputting the emotion, the user taps the "Send" button, which sends the emotion data from the device to the server.

[0064] Step 3:

[0065] The terminal generates a request including the emotion data input by the user and the current date and time, and transmits it to the server.

[0066] Step 4:

[0067] The server processes the emotion data received from the device, which includes the type of emotion and the recording date and time.

[0068] Step 5:

[0069] The server records the received emotion data in an emotion log for each user. For example, it stores it in a database in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[0070] Step 6:

[0071] The server notifies the terminal that the emotion data has been successfully saved.

[0072] Step 7:

[0073] The terminal displays the message "Emotion recorded" to the user, indicating that the emotion has been successfully recorded.

[0074] Providing Reflection Messages

[0075] Step 1:

[0076] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0077] Step 2:

[0078] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[0079] Step 3:

[0080] The terminal sends a request for a reflection prompt to the server.

[0081] Step 4:

[0082] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[0083] Step 5:

[0084] The server sends the selected reflection prompt to the terminal.

[0085] Step 6:

[0086] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[0087] This allows users to efficiently take care of themselves mentally through recording their emotions and reflecting on them weekly.

[0088] Example 1

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

[0090] In modern society, stress and anxiety are on the rise, and many people feel the need for mental health care. To address this issue, it is important to help individuals easily record their emotions on a daily basis and understand their own mental state. However, conventional mental health care systems have struggled to provide effective methods for promoting self-understanding in users.

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

[0092] In this invention, the server includes means for receiving emotion data entered by the user, means for saving the received emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, means for displaying the provided message to the user, and means for notifying the user that transmission of the emotion data has been completed. This allows the user to easily record their daily emotions and periodically reflect on them using the prompts, thereby enabling efficient self-understanding and mental care.

[0093] "User" refers to an individual or end user who uses the system.

[0094] "Emotion data" is information about the user's own emotional state that is input by the user, and includes the type of emotion and the date and time when it was recorded.

[0095] A "database" is a system that organizes and stores collected data and manages it so that it can be searched and updated later.

[0096] "Reflection prompts" are questions or messages that are presented periodically to users with the aim of deepening their self-understanding.

[0097] A "message selection means" is a method or algorithm that selects messages from a message list, either randomly or according to specified criteria, to provide a reflection prompt.

[0098] "Means for displaying to the user" refers to the function or method for displaying the selected message and the recorded emotion on the user's terminal.

[0099] "Means for receiving emotion data" refers to the functions and methods for receiving emotion data entered by the user on the server side.

[0100] "Means for storing emotion data" refers to functions and methods for safely and securely recording received emotion data in a database.

[0101] "Means for notifying that transmission of emotion data has been completed" refers to a function or method for notifying the user that emotion data has been successfully transmitted to the server and has been saved.

[0102] The "Self-Mental Care Coach" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. A specific embodiment of this system will be described below.

[0103] User emotion record

[0104] Displaying the emotion input screen

[0105] The device launches the application and displays an interface (emotion input screen) for the user to input emotions. The screen is built using React Native and Swift and includes a text field for inputting emotions and a "Submit" button. The user enters their current emotion (e.g., "happy," "sad," etc.).

[0106] Sending emotional data

[0107] When the user taps the "Send" button, the device sends the entered emotion data and the current date and time to the server using an HTTPS request, including the user authentication token.

[0108] Storing Emotional Data

[0109] The server processes the received emotion data and records it in a database (e.g., PostgreSQL or MongoDB). The data is saved in a format like {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[0110] Recording completion notification

[0111] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions have been recorded."

[0112] Providing Reflection Messages

[0113] Reflection screen display

[0114] When a user selects "Weekly Reflection" from the application menu, the device displays the reflection screen. The user taps the "Receive Prompt" button.

[0115] Request Reflection Prompt

[0116] The terminal sends prompts to the server based on the user's request.

[0117] Selecting a Reflection Prompt

[0118] When the server receives a request, it randomly selects one message from the list of reflected messages, for example the prompt "What was the happiest moment of this week?"

[0119] Sending a Reflection Prompt

[0120] The server sends the selected prompt to the terminal, which displays the message to the user.

[0121] Specific examples

[0122] Examples of emotion recording

[0123] The user opens the application and enters their current emotion, "Happy." When they tap the "Send" button, the device sends the emotion data "Happy" and the current date and time to the server. The server adds the received data to the user's emotion log and notifies them that the recording was successful. The device displays "Emotion recorded."

[0124] Specific examples of reflection messages

[0125] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user. This allows the user to record their daily emotions and deepen self-understanding through weekly reflection.

[0126] Through this series of processes, users will be able to take efficient self-care of their mental health, which is expected to contribute to improving their mental health.

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

[0128] Step 1:

[0129] Displaying the emotion input screen

[0130] When a user launches the application, the device displays an emotion input screen. The screen includes a text field for entering emotions and a "Submit" button. The input is the user's current emotion. The output is the text field with the emotion entered. In concrete terms, the application is built using React Native or Swift, and the user launches the application by tapping the screen.

[0131] Step 2:

[0132] Entering emotion data

[0133] The user enters their emotion (e.g., "happy," "sad," etc.) into a text field on the emotion input screen. As input, the user enters a specific emotion. As output, that emotion is displayed in the text field. Specifically, the user enters their emotion using the keyboard.

[0134] Step 3:

[0135] Sending emotional data

[0136] When the user taps the "Send" button, the device sends the entered emotion data and the current date and time to the server. At this time, the data is sent using an HTTPS request. The inputs are emotion data and the current date and time. The output is sent to the server. Specifically, the device uses JavaScript (registered trademark) or Axios to send the emotion data in JSON format.

[0137] Step 4:

[0138] Storing Emotional Data

[0139] The server processes the received emotion data and stores it in a database. PostgreSQL or MongoDB is used as the database. The input is the received emotion data and the current date and time. The output is the data stored in the database. Specifically, the server executes a database operation command to record the emotion data in the database in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[0140] Step 5:

[0141] Recording completion notification

[0142] The server notifies the device that the emotion data has been successfully saved. The input is information that the emotion data has been successfully saved. The output is a notification message to the device. Specifically, the server generates an HTTP response and sends a message to the device saying "Emotions recorded." The device then displays this message to the user.

[0143] Step 6:

[0144] Reflection screen display

[0145] When a user selects "Weekly Reflection" from the application menu, the device displays the reflection screen. The input is the user's selection operation. The output is the display of the reflection screen. In concrete terms, the user operates the screen to select the "Weekly Reflection" menu.

[0146] Step 7:

[0147] Request Reflection Prompt

[0148] When the "Receive Prompt" button is tapped, the device requests a prompt from the server. The input is the user tapping the "Receive Prompt" button. The output is a prompt request to the server. The specific operation is that the device generates an HTTP request and sends it to the server.

[0149] Step 8:

[0150] Selecting a Reflection Prompt

[0151] The server randomly selects one message from the list of reflected messages based on the received request. The input is the request. The output is the selected prompt message. Specifically, the server selects one message from the reflected message list using a random algorithm.

[0152] Step 9:

[0153] Sending a Reflection Prompt

[0154] The server sends the selected prompt to the terminal, and the terminal displays that message to the user. The input is the selected prompt message. The output is the message displayed to the user. In concrete terms, the server sends the prompt message as an HTTP response, and the terminal receives the message and displays it on the reflection screen.

[0155] By following these steps, users can input and record their own emotions and receive periodic reflection prompts. We hope that this system will promote self-understanding and mental health care for users.

[0156] (Application example 1)

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

[0158] In modern workplaces, employee mental health has become a critical issue. In particular, in brick-and-mortar stores such as retail and service industries, employee stress often directly impacts the quality of customer service. Therefore, effective methods for supporting employee mental health and improving the quality of customer service are needed. To address this issue, the present invention aims to provide a system that allows employees to record their daily emotions and periodically provides reflection prompts to deepen self-understanding.

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

[0160] In this invention, the server includes means for receiving emotion data entered by a user, means for storing the received emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, means for displaying the provided message to the user, and means for employees to record their daily work emotions and provide a reflection message each week to promote self-understanding. This allows employees to objectively reflect on their own emotions, deepening self-understanding and improving their mental health, which in turn makes it possible to improve the quality of customer service.

[0161] "Emotion data" is data including the current emotion entered by the user and its details.

[0162] "Reflection prompts" are questions or messages that are periodically provided to users to encourage them to reflect on their own feelings and experiences.

[0163] A "database" is a structured system of record for storing received emotion data.

[0164] A "server" is a computer system on a network that is responsible for receiving and storing emotion data and providing reflection prompts.

[0165] An "emotion input screen" is an interface that allows users to input their own emotions, and is displayed on smartphones and other devices.

[0166] A "random selection method" is an algorithm or method for randomly selecting a reflection prompt or message from a list.

[0167] A "brick and mortar store" is a retail or service establishment that exists in a physical location and is a face-to-face environment between employees and customers.

[0168] "Employees" are workers who deal with customers and perform other tasks in physical stores, and are the recipients of mental health care and who record their emotions during their daily work.

[0169] The "Self Mental Care Coach" system of the present invention provides a mental care application for employees of brick-and-mortar stores. Specific embodiments for carrying out the present invention will be described below.

[0170] Emotion recording function

[0171] Before starting or after work, users launch the smartphone application and input their current emotions. This emotion recording is done from the emotion input screen. The emotion input screen has an intuitive interface designed to allow users to easily input their emotions. For example, users can enter emotions such as "happy" or "sad" in a text field.

[0172] The device sends the emotion data entered by the user and the current date and time to the server. The server stores the received emotion data in a database, for example, in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}. If the emotion data is successfully saved, the server notifies the device, and the device displays "Emotion recorded."

[0173] Reflection prompt function

[0174] At the end of the week, users select "Weekly Reflection" from the application menu and tap the button to receive the prompt. The device then sends a request for a reflection prompt to the server.

[0175] When the server receives the request, it randomly selects one message from the list of reflection messages, for example, "What was the happiest moment of this week?" The server then sends the selected reflection prompt to the device, which displays the message to the user.

[0176] Natural language description of the process

[0177] The main processing of this system involves several pieces of hardware and software. The devices used are mainly smartphones, with the necessary applications for emotion input and prompt display installed. The server uses Flask, a Python microweb framework, to receive and store emotion data and select reflection messages. Emotion data is stored in a simple database, and the Python random module is used to select random prompts.

[0178] Specific examples

[0179] Examples of emotion recording

[0180] The user opens the smartphone application, inputs their current emotion, "Happy," and taps the "Send" button. The device sends the emotion data, "Happy," and the current date and time to the server. The server adds the received data to the user's emotion log and notifies them that the recording was successful. The device displays a notification saying, "Emotion recorded."

[0181] Specific examples of reflection messages

[0182] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[0183] Prompt Sentence Examples

[0184] "What was your happiest moment this week?"

[0185] "What was your most stressful moment this week?"

[0186] "Tell me one thing you learned this week."

[0187] "What did you feel you could improve this week?"

[0188] This system allows employees to record their daily emotions and deepen self-understanding through weekly reflection, which is expected to contribute to improving mental health.

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

[0190] Step 1:

[0191] Before starting work, the user launches the smartphone application and inputs their current emotions. The input emotion data (e.g., "happy") and the current date and time are treated as input data. This data is collected through the emotion input screen.

[0192] Step 2:

[0193] The device generates a request including the emotion data entered by the user and the current date and time, and sends it to the server. The data transmission request includes emotion data and time data, and uses JSON as the data format.

[0194] Step 3:

[0195] The server processes the data received from the device and stores it in a database. The received emotion data is recorded in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}. The server checks whether the data was saved successfully and notifies the device of the result.

[0196] Step 4:

[0197] The device receives the notification from the server and displays a confirmation message to the user saying, "Emotions have been recorded." This lets the user know that the input emotion data has been successfully recorded.

[0198] Step 5:

[0199] At the end of the week, users open the application on their smartphone, select the "Weekly Reflection" menu, and tap the "Receive Prompt" button, which generates a request for a reflection prompt.

[0200] Step 6:

[0201] The device sends a request for a reflection prompt to the server, which includes the user's identity and arranges for the server to provide an appropriate prompt for each user.

[0202] Step 7:

[0203] When the server receives a request, it randomly selects one message from the list of reflection messages. The Python random module is used to select the reflection message. The selected message (e.g., "What was the happiest moment of this week?") is generated.

[0204] Step 8:

[0205] The server sends the selected reflection prompt to the terminal. The sent data includes the selected prompt message and uses JSON as the data format.

[0206] Step 9:

[0207] The device displays the reflection prompts received from the server to the user, allowing the user to deepen their self-understanding based on the prompts provided as weekly reflections.

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

[0209] The "Self-Mental Care Coach" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. Furthermore, the present invention combines an emotion engine to recognize the user's emotions and provide more accurate mental care. Specific embodiments of this system will be described below.

[0210] User emotion record

[0211] 1. Display the emotion input screen

[0212] The device starts the application and displays an interface (emotion input screen) for the user to input emotions. The user inputs their current emotion (e.g., "happy," "sad," etc.) in a text field.

[0213] 2. Sending Emotional Data

[0214] After inputting the emotion, the user taps the "Send" button, which sends the emotion data from the device to the server.

[0215] 3. Emotion Data Analysis

[0216] The server analyzes the emotion data received from the device using an emotion engine, which uses natural language processing technology and machine learning algorithms to recognize the user's emotions.

[0217] 4. Storing Emotional Data

[0218] The server records the analyzed emotion data in an emotion log for each user, for example, in the form {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} in the database.

[0219] 5. Recording completion notification

[0220] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions recorded."

[0221] Providing Reflection Messages

[0222] 1. Displaying the reflection screen

[0223] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0224] 2. Request a Reflection Prompt

[0225] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[0226] 3. Select a reflection prompt

[0227] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[0228] 4. Sending a Reflection Prompt

[0229] The server sends the selected reflection prompt to the terminal.

[0230] 5. Displaying the Reflection Prompt

[0231] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[0232] Specific examples

[0233] Examples of emotion recording

[0234] The user opens the application and enters their current emotion, "Happy." When they tap the "Send" button, the device sends the emotion data "Happy" and the current date and time to the server. The server analyzes the received data with its emotion engine and recognizes the emotion "Happy." It then adds this data to the user's emotion log and notifies them that it was successfully recorded. The device displays "Emotion recorded."

[0235] Specific examples of reflection messages

[0236] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[0237] This allows users to efficiently take care of themselves through recording their emotions and weekly reflection. In addition, by utilizing the emotion engine, the system can more accurately recognize users' emotions and provide appropriate feedback.

[0238] The processing flow will be explained below.

[0239] Processing emotion records

[0240] Step 1:

[0241] The terminal displays a screen for the user to input their current emotion. The user inputs their current emotion in a text field.

[0242] Step 2:

[0243] The user can send the emotion they have entered by tapping the "Send" button. This operation sends the emotion data from the device to the server.

[0244] Step 3:

[0245] The terminal generates a request including the emotion data input by the user and the current date and time, and transmits it to the server.

[0246] Step 4:

[0247] The server processes the emotion data received from the device and analyzes it using an emotion engine, which uses natural language processing technology and machine learning algorithms to recognize emotions from the user's text input.

[0248] Step 5:

[0249] The server records the analyzed emotion data in an emotion log for each user, for example, in the form {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} in the database.

[0250] Step 6:

[0251] The server notifies the terminal that the emotion data has been successfully saved.

[0252] Step 7:

[0253] The terminal displays the message "Emotion recorded" to the user, indicating that the emotion has been successfully recorded.

[0254] Providing Reflection Messages

[0255] Step 1:

[0256] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0257] Step 2:

[0258] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[0259] Step 3:

[0260] The terminal sends a request to the server.

[0261] Step 4:

[0262] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[0263] Step 5:

[0264] The server sends the selected reflection prompt to the terminal.

[0265] Step 6:

[0266] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[0267] Specific examples

[0268] Examples of emotion recording

[0269] Step 1:

[0270] The device displays a screen for the user to input an emotion. For example, the user inputs "happy."

[0271] Step 2:

[0272] After entering "happy," the user taps the "Send" button.

[0273] Step 3:

[0274] The terminal generates a request including emotion data "happy" and the current date and time, and sends it to the server.

[0275] Step 4:

[0276] The server receives the emotion data and analyzes it with the emotion engine, which recognizes the emotion "happiness."

[0277] Step 5:

[0278] The server records the recognized emotion data in an emotion log for each user. For example, the data {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} is stored in the database.

[0279] Step 6:

[0280] The server notifies the terminal that the emotion data has been successfully saved.

[0281] Step 7:

[0282] The terminal displays the message "Emotions recorded" to the user.

[0283] Specific examples of reflection messages

[0284] Step 1:

[0285] The terminal displays the "Weekly Reflection" screen to the user.

[0286] Step 2:

[0287] The user taps the "Accept Prompt" button.

[0288] Step 3:

[0289] The terminal sends a request to the server.

[0290] Step 4:

[0291] The server receives the request and randomly selects the message "What was the happiest moment this week?" from the list of reflected messages.

[0292] Step 5:

[0293] The server sends the selected message to the terminal.

[0294] Step 6:

[0295] The device displays the message to the user: "What was the happiest moment this week?"

[0296] This allows users to efficiently take care of themselves through recording their emotions and weekly reflection. In addition, by utilizing the emotion engine, the system can more accurately recognize users' emotions and provide appropriate feedback.

[0297] Example 2

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

[0299] There is a need to provide an efficient means to promote self-understanding and mental health care for users. However, existing methods have the problem of making it difficult for users to accurately record their emotions and receive appropriate feedback based on them. In particular, analyzing emotional data and providing reflection prompts is often done manually, which is time-consuming and labor-intensive, and can have low accuracy.

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

[0301] In this invention, the server includes means for receiving emotion data input by a user, means including a natural language processing engine for analyzing the received emotion data, means for storing the analyzed emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, and means for displaying the selected reflection prompt to the user, thereby enabling the user to conveniently record their emotions and receive appropriate feedback based on the analyzed data.

[0302] "Emotion data" is information about an emotion input by a user, and includes the type of emotion and the date and time when the emotion was recorded.

[0303] A "natural language processing engine" is a computer program for understanding and analyzing human language and is used to automatically recognize emotions.

[0304] "Database" means an information system for storing and managing received and analyzed emotion data, and for efficiently searching and updating the data.

[0305] "Reflection prompts" are questions or messages that encourage self-reflection in users, encouraging them to reflect on their feelings and experiences.

[0306] "Message selection" is the process of randomly choosing an appropriate message from multiple candidates to provide a reflection prompt.

[0307] "Emotion recording" refers to a series of processes that receive emotion data entered by the user, analyze it, and store the analysis results in a database.

[0308] The "Self-Mental Care Coach" system of this invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. Furthermore, the present invention combines an emotion engine to recognize the user's emotions and provide more accurate mental care. Specific embodiments of this system will be described below.

[0309] This system is based on communication between the server, the terminal, and the user. It mainly uses the following main components:

[0310] Hardware and software used

[0311] Servers (e.g., cloud servers or on-premise servers)

[0312] Terminals (mobile devices such as smartphones and tablets)

[0313] A database (e.g., MySQL or MongoDB)

[0314] Natural language processing engines (e.g., BERT models and other machine learning algorithms)

[0315] Applications (mobile applications used by users)

[0316] Key System Features

[0317] 1. Record your emotions

[0318] Phase 1: Application Launch

[0319] When a user launches the application, the device displays an emotion input screen, which includes a text field (for entering emotions) and a "Send" button.

[0320] Phase 2: Enter and send emotion data

[0321] The user inputs their emotion and taps the "Send" button, which sends the emotion data (e.g., "happy," "sad," etc.) and the current date and time from the device to the server.

[0322] Phase 3: Analyzing the emotion data

[0323] The server analyzes the received emotion data using a natural language processing engine, which then analyzes the emotion data and determines which emotion it corresponds to, such as "happy" or "sad."

[0324] Phase 4: Storing Emotional Data

[0325] The server stores the analyzed emotion data in a database as an emotion log for each user, for example, in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[0326] Phase 5: Recording completion notification

[0327] The server notifies the device that the emotion data has been successfully saved, and the device displays a message to the user saying "Emotions recorded."

[0328] 2. Providing reflection prompts

[0329] Step 1: Displaying the reflection screen

[0330] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0331] Phase 2: Request a Reflection Prompt

[0332] The user taps the "Accept Prompt" button, which sends a request from the device to the server.

[0333] Phase 3: Selecting a reflection prompt

[0334] Based on the received request, the server randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[0335] Phase 4: Sending a Reflection Prompt

[0336] The server sends the selected reflection prompt to the terminal.

[0337] Phase 5: Displaying the Reflection Prompt

[0338] The device will then display the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[0339] Specific examples

[0340] Examples of emotion recording

[0341] The user opens the application, enters their current emotion "Happy", and taps the "Send" button. The device sends the emotion data "Happy" and the current date and time to the server via an HTTP POST request. The server analyzes the received data using a natural language processing engine (e.g., the BERT model) and stores the results in a database. Finally, the device displays a message to the user saying "Emotion recorded."

[0342] Specific examples of reflection messages

[0343] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list and sends it to the device. The device then displays this message to the user.

[0344] This system allows users to efficiently take care of themselves through recording and reflecting on their emotions. In addition, by utilizing the emotion engine, the system can more accurately recognize users' emotions and provide appropriate feedback.

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

[0346] Emotion recording processing steps

[0347] Step 1:

[0348] The device launches the application and displays the emotion input screen.

[0349] Specific operation: When a user taps the app icon, the device loads the home screen and displays the emotion input page, which is the input.

[0350] Step 2:

[0351] The user enters their emotion into the input field and taps the "Send" button.

[0352] Specific behavior: When the user enters an emotion, such as "happy," into the text field and taps the "Submit" button, this becomes the input data.

[0353] Step 3:

[0354] The device sends emotion data (e.g., "happy") and the current date and time to the server as an HTTP POST request.

[0355] Specific operation: When the send button is pressed, the device generates JSON format data that combines emotion data and the current date and time, and sends it to the server. The output here is the sent data.

[0356] Step 4:

[0357] The server analyzes the received emotional data using a natural language processing engine.

[0358] Specific operation: The server inputs the received data into an analysis engine (e.g., BERT model) and performs data calculations. The analysis engine analyzes the text data and recognizes the type of emotion. The output is an emotion label based on the analysis result.

[0359] Step 5:

[0360] The server stores the analyzed emotion data in a database for each user.

[0361] Specific operation: The server records the analysis result and timestamp in the database in the format '{time': '2023-10-05 14:23:45', 'emotion': 'happy'}. The input is the analysis result and timestamp, and the output is the saved data.

[0362] Step 6:

[0363] The server notifies the device that the emotion data has been successfully saved, and the device displays a message to the user saying "Emotions recorded."

[0364] Specific behavior: The server returns the save completion status to the device, and the device displays a popup or toast notification. The input here is the save completion status, and the output is the notification displayed to the user.

[0365] Steps for Providing Reflection Prompts

[0366] Step 1:

[0367] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0368] Specific behavior: When a user selects the weekly reflection option from the menu, the device loads and displays the corresponding screen. The input is the user's operation, and the output is the display of the reflection screen.

[0369] Step 2:

[0370] The user taps the "Accept Prompt" button.

[0371] Specific behavior: When the user taps the "Accept Prompt" button, this becomes the input.

[0372] Step 3:

[0373] The terminal sends the request to the server.

[0374] Specific behavior: The request is sent to the server as an HTTP request. The input is the request from the user, and the output is the request sent.

[0375] Step 4:

[0376] Based on the received request, the server randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[0377] Specific behavior: The server randomly selects one from the prompt list and retrieves it. The input is the request and the prompt list, and the output is the selected message.

[0378] Step 5:

[0379] The server sends the selected reflection prompt to the terminal.

[0380] Specific operation: The server returns an HTTP response containing the selected message to the terminal. The input is the selected message, and the output is the HTTP response.

[0381] Step 6:

[0382] The terminal displays the received reflection prompt to the user.

[0383] Specific operation: The terminal displays the received message on the screen and presents it to the user. The input here is the HTTP response, and the output is the prompt message displayed to the user.

[0384] (Application example 2)

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

[0386] Mental health has become a major issue in modern society. It is particularly important for individuals to appropriately manage their emotions and reduce mental stress. However, in busy daily lives, it is difficult to regularly record and analyze emotions, and it is also difficult to respond immediately when excessive stress occurs. There is a need for a system that can solve these problems and efficiently support users' mental health.

[0387] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving emotion data input by the user, means for saving the received emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, and means for notifying an emergency contact when excessive mental stress is detected. This makes it possible to periodically record and analyze the user's emotions, provide feedback at an appropriate time, and respond quickly in an emergency.

[0388] "Emotion data" refers to information relating to emotions input by a user, and is digital information that indicates the user's emotional state.

[0389] A "database" is a system for systematically storing and managing received emotion data, and is an information resource for efficiently managing large amounts of data.

[0390] "Reflection prompts" are messages that encourage users to self-awareness and reflect on their emotions, and are leading questions that allow users to reevaluate their own emotions.

[0391] "Mental stress" refers to a state of psychological or emotional pressure or tension, and refers to the mental burden on the user.

[0392] An "emergency contact" is a contact to be notified when the user experiences excessive mental stress, and is a person to be contacted in an emergency.

[0393] The "Self-Mental Care Guard" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. It also has a function to notify emergency contacts if excessive mental stress is detected. A specific embodiment of this system will be described below.

[0394] User emotion record

[0395] 1. Display the emotion input screen

[0396] The terminal starts the application and displays an interface (emotion input screen) for the user to input emotions.

[0397] The user enters their current emotion (e.g., "happy," "sad," etc.) in a text field.

[0398] 2. Sending Emotional Data

[0399] After inputting the emotion, the user taps the "Send" button, which sends the emotion data from the device to the server.

[0400] 3. Emotion Data Analysis

[0401] The server analyzes the emotion data received from the device using an emotion engine, which uses natural language processing technology and machine learning algorithms to recognize the user's emotions.

[0402] 4. Storing Emotional Data

[0403] The server records the analyzed emotion data in an emotion log for each user, for example, in the form {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} in the database.

[0404] 5. Recording completion notification

[0405] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions recorded."

[0406] Providing Reflection Messages

[0407] 1. Displaying the reflection screen

[0408] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0409] 2. Request a Reflection Prompt

[0410] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[0411] 3. Select a reflection prompt

[0412] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[0413] 4. Sending a Reflection Prompt

[0414] The server sends the selected reflection prompt to the terminal.

[0415] 5. Displaying the Reflection Prompt

[0416] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[0417] Emergency notification function

[0418] 1. Detecting mental stress

[0419] The server analyzes the emotional data and detects if the user's mental stress level is high.

[0420] 2. Notification to emergency contacts

[0421] If an emergency call is deemed necessary, the server sends a notification to the user's designated emergency contacts, including a summary of the user's current mental state.

[0422] Hardware and software used

[0423] Device: Smartphone

[0424] Server: Cloud server (e.g., AWS (registered trademark), Google (registered trademark) Cloud)

[0425] Database: SQL database (e.g. MySQL, PostgreSQL)

[0426] Emotion engine: Natural language processing technology and machine learning algorithms (e.g., Python's NLTK, TENSORFLOW®)

[0427] Communication library: requests library

[0428] Specific examples

[0429] Examples of emotion recording

[0430] The user opens the application and enters their current emotion, "Sad." When they tap the "Send" button, the device sends the emotion data "Sad" and the current date and time to the server. The server analyzes the received data with its emotion engine and recognizes the emotion "Sad." It then adds this data to the user's emotion log and notifies them that it was successfully recorded. The device then displays "Emotion recorded."

[0431] Specific examples of reflection messages

[0432] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[0433] Example of operation

[0434] Prompt Sentence Examples

[0435] "What was your happiest moment this week?"

[0436] By utilizing a generative AI model, we can realize effective self-mental care and support the user's mental health. This system allows users to efficiently practice self-mental care through recording their emotions and weekly reflection. It also enables rapid response in emergencies.

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

[0438] Step 1:

[0439] The device displays an interface (emotion input screen) for the user to input emotions. This interface includes a text field for inputting emotions and a "Send" button. The user enters the current emotion in the text field and taps the "Send" button.

[0440] Input: Emotion data entered by the user

[0441] Output: Emotion data is sent to the device.

[0442] Step 2:

[0443] When the user taps the "Send" button, the device sends the entered emotion data and the current date and time to the server. At this stage, the device packages the emotion data in JSON format or similar and sends it to the server using an HTTP request.

[0444] Input: Emotion data entered into the device and the current date and time

[0445] Output: Emotion data and date and time are sent to the server.

[0446] Step 3:

[0447] The server analyzes the emotion data received from the device. Specifically, an emotion engine running on the server analyzes the received data and recognizes the user's emotion. The emotion engine uses natural language processing technology and machine learning algorithms. Through this analysis, the emotion data is recognized as emotions such as "happy" or "sad."

[0448] Input: Emotion data and date and time sent to the server

[0449] Output: Parsed emotion data

[0450] Step 4:

[0451] The server stores the analyzed emotion data in a database. At this time, the emotion data is recorded as an emotion log for each user. For example, the data is stored in the format {'time': '2023-10-05 14:23:45', 'emotion': 'Happy'}.

[0452] Input: Parsed emotion data

[0453] Output: Emotion data is saved in the database

[0454] Step 5:

[0455] The server notifies the device that the emotion data has been successfully saved. The device then displays a message to the user saying, "Emotions have been recorded." This message lets the user know that their emotion has been recorded.

[0456] Input: Save completion notification from the server

[0457] Output: Display the message "Emotions recorded" on the terminal.

[0458] Step 6:

[0459] The user selects the "Weekly Reflection" menu and taps the "Receive Prompt" button. The device sends a reflection prompt request to the server. The request includes the user ID and reflection prompt request metadata.

[0460] Input: Reflection prompt request from user

[0461] Output: The request is sent to the server

[0462] Step 7:

[0463] When the server receives the request, it randomly selects a prompt from the list of reflection messages. For example, the message "What was the happiest moment of this week?" is selected and sent from the server to the device.

[0464] Input: Reflection prompt request from user

[0465] Output: A randomly chosen reflection message is sent to the terminal.

[0466] Step 8:

[0467] The device displays the reflection prompt received from the server to the user, allowing the user to reflect on their self-awareness and emotions.

[0468] Input: Reflected prompt sent from the server

[0469] Output: A reflection prompt appears in the terminal

[0470] Step 9:

[0471] The server analyzes the emotional data and detects if the user's mental stress level is high. Specifically, it analyzes past emotional logs and detects excessive stress if a certain threshold is exceeded.

[0472] Input: Emotion data stored on the server

[0473] Output: Mental stress level evaluation results

[0474] Step 10:

[0475] If excessive mental stress is detected, the server sends a notification to the user's designated emergency contacts, along with a summary of the user's current mental state.

[0476] Input: Mental stress level assessment results

[0477] Output: Notification sent to emergency contacts

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

[0479] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (registered trademark) (Internet search engine).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (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.

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

[0481] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0494] The "Self-Mental Care Coach" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. Specific embodiments of this system will be described below.

[0495] User emotion record

[0496] 1. Display the emotion input screen

[0497] The device starts the application and displays an interface (emotion input screen) for the user to input emotions. The user inputs their current emotion (e.g., "happy," "sad," etc.) in a text field.

[0498] 2. Sending Emotional Data

[0499] After entering their emotion, the user taps the "Send" button, which causes the device to request the server to send the emotion data they entered. At the same time, the current date and time are also attached to the request.

[0500] 3. Emotional Data Storage

[0501] The server processes the emotion data received from the device and records it in the user's emotion log (database). For example, the emotion data is saved in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[0502] 4. Recording completion notification

[0503] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions recorded."

[0504] Providing Reflection Messages

[0505] 1. Displaying the reflection screen

[0506] The device displays the reflection screen to the user who selects "Weekly Reflection" from the application menu. The user taps the "Receive Prompt" button.

[0507] 2. Request a Reflection Prompt

[0508] The terminal transmits a request for a reflection prompt from the user to the server.

[0509] 3. Select a reflection prompt

[0510] When the server receives a request, it randomly selects one message from the list of reflected messages, for example a prompt such as "What was the happiest moment of your week?"

[0511] 4. Sending a Reflection Prompt

[0512] The server sends the selected reflection prompt to the terminal, which displays the message to the user.

[0513] Specific examples

[0514] Examples of emotion recording

[0515] The user opens the application and enters their current emotion, "Happy." When they tap the "Send" button, the device sends the emotion data "Happy" and the current date and time to the server. The server adds the received data to the user's emotion log and notifies them that the recording was successful. The device displays "Emotion recorded."

[0516] Specific examples of reflection messages

[0517] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[0518] This allows users to record their daily emotions and deepen self-understanding through weekly reflection, which is expected to enable efficient self-mental care and contribute to improving mental health.

[0519] The processing flow will be explained below.

[0520] Processing emotion records

[0521] Step 1:

[0522] The terminal displays a screen for the user to input an emotion, and the user inputs the current emotion in a text field on the emotion input screen.

[0523] Step 2:

[0524] After inputting the emotion, the user taps the "Send" button, which sends the emotion data from the device to the server.

[0525] Step 3:

[0526] The terminal generates a request including the emotion data input by the user and the current date and time, and transmits it to the server.

[0527] Step 4:

[0528] The server processes the emotion data received from the device, which includes the type of emotion and the recording date and time.

[0529] Step 5:

[0530] The server records the received emotion data in an emotion log for each user. For example, it stores it in a database in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[0531] Step 6:

[0532] The server notifies the terminal that the emotion data has been successfully saved.

[0533] Step 7:

[0534] The terminal displays the message "Emotion recorded" to the user, indicating that the emotion has been successfully recorded.

[0535] Providing Reflection Messages

[0536] Step 1:

[0537] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0538] Step 2:

[0539] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[0540] Step 3:

[0541] The terminal sends a request for a reflection prompt to the server.

[0542] Step 4:

[0543] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[0544] Step 5:

[0545] The server sends the selected reflection prompt to the terminal.

[0546] Step 6:

[0547] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[0548] This allows users to efficiently take care of themselves mentally through recording their emotions and reflecting on them weekly.

[0549] Example 1

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

[0551] In modern society, stress and anxiety are on the rise, and many people feel the need for mental health care. To address this issue, it is important to help individuals easily record their emotions on a daily basis and understand their own mental state. However, conventional mental health care systems have struggled to provide effective methods for promoting self-understanding in users.

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

[0553] In this invention, the server includes means for receiving emotion data entered by the user, means for saving the received emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, means for displaying the provided message to the user, and means for notifying the user that transmission of the emotion data has been completed. This allows the user to easily record their daily emotions and periodically reflect on them using the prompts, thereby enabling efficient self-understanding and mental care.

[0554] "User" refers to an individual or end user who uses the system.

[0555] "Emotion data" is information about the user's own emotional state that is input by the user, and includes the type of emotion and the date and time when it was recorded.

[0556] A "database" is a system that organizes and stores collected data and manages it so that it can be searched and updated later.

[0557] "Reflection prompts" are questions or messages that are presented periodically to users with the aim of deepening their self-understanding.

[0558] A "message selection means" is a method or algorithm that selects messages from a message list, either randomly or according to specified criteria, to provide a reflection prompt.

[0559] "Means for displaying to the user" refers to the function or method for displaying the selected message and the recorded emotion on the user's terminal.

[0560] "Means for receiving emotion data" refers to the functions and methods for receiving emotion data entered by the user on the server side.

[0561] "Means for storing emotion data" refers to functions and methods for safely and securely recording received emotion data in a database.

[0562] "Means for notifying that transmission of emotion data has been completed" refers to a function or method for notifying the user that emotion data has been successfully transmitted to the server and has been saved.

[0563] The "Self-Mental Care Coach" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. A specific embodiment of this system will be described below.

[0564] User emotion record

[0565] Displaying the emotion input screen

[0566] The device launches the application and displays an interface (emotion input screen) for the user to input emotions. The screen is built using React Native and Swift and includes a text field for inputting emotions and a "Submit" button. The user enters their current emotion (e.g., "happy," "sad," etc.).

[0567] Sending emotional data

[0568] When the user taps the "Send" button, the device sends the entered emotion data and the current date and time to the server using an HTTPS request, including the user authentication token.

[0569] Storing Emotional Data

[0570] The server processes the received emotion data and records it in a database (e.g., PostgreSQL or MongoDB). The data is saved in a format like {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[0571] Recording completion notification

[0572] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions have been recorded."

[0573] Providing Reflection Messages

[0574] Reflection screen display

[0575] When a user selects "Weekly Reflection" from the application menu, the device displays the reflection screen. The user taps the "Receive Prompt" button.

[0576] Request Reflection Prompt

[0577] The terminal sends prompts to the server based on the user's request.

[0578] Selecting a Reflection Prompt

[0579] When the server receives a request, it randomly selects one message from the list of reflected messages, for example the prompt "What was the happiest moment of this week?"

[0580] Sending a Reflection Prompt

[0581] The server sends the selected prompt to the terminal, which displays the message to the user.

[0582] Specific examples

[0583] Examples of emotion recording

[0584] The user opens the application and enters their current emotion, "Happy." When they tap the "Send" button, the device sends the emotion data "Happy" and the current date and time to the server. The server adds the received data to the user's emotion log and notifies them that the recording was successful. The device displays "Emotion recorded."

[0585] Specific examples of reflection messages

[0586] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user. This allows the user to record their daily emotions and deepen self-understanding through weekly reflection.

[0587] Through this series of processes, users will be able to take efficient self-care of their mental health, which is expected to contribute to improving their mental health.

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

[0589] Step 1:

[0590] Displaying the emotion input screen

[0591] When a user launches the application, the device displays an emotion input screen. The screen includes a text field for entering emotions and a "Submit" button. The input is the user's current emotion. The output is the text field with the emotion entered. In concrete terms, the application is built using React Native or Swift, and the user launches the application by tapping the screen.

[0592] Step 2:

[0593] Entering emotion data

[0594] The user enters their emotion (e.g., "happy," "sad," etc.) into a text field on the emotion input screen. As input, the user enters a specific emotion. As output, that emotion is displayed in the text field. Specifically, the user enters their emotion using the keyboard.

[0595] Step 3:

[0596] Sending emotional data

[0597] When the user taps the "Send" button, the device sends the entered emotion data and the current date and time to the server. At this time, the data is sent using an HTTPS request. The inputs are emotion data and the current date and time. The output is sent to the server. Specifically, the device uses JavaScript or Axios to send the emotion data in JSON format.

[0598] Step 4:

[0599] Storing Emotional Data

[0600] The server processes the received emotion data and stores it in a database. PostgreSQL or MongoDB is used as the database. The input is the received emotion data and the current date and time. The output is the data stored in the database. Specifically, the server executes a database operation command to record the emotion data in the database in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[0601] Step 5:

[0602] Recording completion notification

[0603] The server notifies the device that the emotion data has been successfully saved. The input is information that the emotion data has been successfully saved. The output is a notification message to the device. Specifically, the server generates an HTTP response and sends a message to the device saying "Emotions recorded." The device then displays this message to the user.

[0604] Step 6:

[0605] Reflection screen display

[0606] When a user selects "Weekly Reflection" from the application menu, the device displays the reflection screen. The input is the user's selection operation. The output is the display of the reflection screen. In concrete terms, the user operates the screen to select the "Weekly Reflection" menu.

[0607] Step 7:

[0608] Request Reflection Prompt

[0609] When the "Receive Prompt" button is tapped, the device requests a prompt from the server. The input is the user tapping the "Receive Prompt" button. The output is a prompt request to the server. The specific operation is that the device generates an HTTP request and sends it to the server.

[0610] Step 8:

[0611] Selecting a Reflection Prompt

[0612] The server randomly selects one message from the list of reflected messages based on the received request. The input is the request. The output is the selected prompt message. Specifically, the server selects one message from the reflected message list using a random algorithm.

[0613] Step 9:

[0614] Sending a Reflection Prompt

[0615] The server sends the selected prompt to the terminal, and the terminal displays that message to the user. The input is the selected prompt message. The output is the message displayed to the user. In concrete terms, the server sends the prompt message as an HTTP response, and the terminal receives the message and displays it on the reflection screen.

[0616] By following these steps, users can input and record their own emotions and receive periodic reflection prompts. We hope that this system will promote self-understanding and mental health care for users.

[0617] (Application example 1)

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

[0619] In modern workplaces, employee mental health has become a critical issue. In particular, in brick-and-mortar stores such as retail and service industries, employee stress often directly impacts the quality of customer service. Therefore, effective methods for supporting employee mental health and improving the quality of customer service are needed. To address this issue, the present invention aims to provide a system that allows employees to record their daily emotions and periodically provides reflection prompts to deepen self-understanding.

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

[0621] In this invention, the server includes means for receiving emotion data entered by a user, means for storing the received emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, means for displaying the provided message to the user, and means for employees to record their daily work emotions and provide a reflection message each week to promote self-understanding. This allows employees to objectively reflect on their own emotions, deepening self-understanding and improving their mental health, which in turn makes it possible to improve the quality of customer service.

[0622] "Emotion data" is data including the current emotion entered by the user and its details.

[0623] "Reflection prompts" are questions or messages that are periodically provided to users to encourage them to reflect on their own feelings and experiences.

[0624] A "database" is a structured system of record for storing received emotion data.

[0625] A "server" is a computer system on a network that is responsible for receiving and storing emotion data and providing reflection prompts.

[0626] An "emotion input screen" is an interface that allows users to input their own emotions, and is displayed on smartphones and other devices.

[0627] A "random selection method" is an algorithm or method for randomly selecting a reflection prompt or message from a list.

[0628] A "brick and mortar store" is a retail or service establishment that exists in a physical location and is a face-to-face environment between employees and customers.

[0629] "Employees" are workers who deal with customers and perform other tasks in physical stores, and are the recipients of mental health care and who record their emotions during their daily work.

[0630] The "Self Mental Care Coach" system of the present invention provides a mental care application for employees of brick-and-mortar stores. Specific embodiments for carrying out the present invention will be described below.

[0631] Emotion recording function

[0632] Before starting or after work, users launch the smartphone application and input their current emotions. This emotion recording is done from the emotion input screen. The emotion input screen has an intuitive interface designed to allow users to easily input their emotions. For example, users can enter emotions such as "happy" or "sad" in a text field.

[0633] The device sends the emotion data entered by the user and the current date and time to the server. The server stores the received emotion data in a database, for example, in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}. If the emotion data is successfully saved, the server notifies the device, and the device displays "Emotion recorded."

[0634] Reflection prompt function

[0635] At the end of the week, users select "Weekly Reflection" from the application menu and tap the button to receive the prompt. The device then sends a request for a reflection prompt to the server.

[0636] When the server receives the request, it randomly selects one message from the list of reflection messages, for example, "What was the happiest moment of this week?" The server then sends the selected reflection prompt to the device, which displays the message to the user.

[0637] Natural language description of the process

[0638] The main processing of this system involves several pieces of hardware and software. The devices used are mainly smartphones, with the necessary applications for emotion input and prompt display installed. The server uses Flask, a Python microweb framework, to receive and store emotion data and select reflection messages. Emotion data is stored in a simple database, and the Python random module is used to select random prompts.

[0639] Specific examples

[0640] Examples of emotion recording

[0641] The user opens the smartphone application, inputs their current emotion, "Happy," and taps the "Send" button. The device sends the emotion data, "Happy," and the current date and time to the server. The server adds the received data to the user's emotion log and notifies them that the recording was successful. The device displays a notification saying, "Emotion recorded."

[0642] Specific examples of reflection messages

[0643] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[0644] Prompt Sentence Examples

[0645] "What was your happiest moment this week?"

[0646] "What was your most stressful moment this week?"

[0647] "Tell me one thing you learned this week."

[0648] "What did you feel you could improve this week?"

[0649] This system allows employees to record their daily emotions and deepen self-understanding through weekly reflection, which is expected to contribute to improving mental health.

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

[0651] Step 1:

[0652] Before starting work, the user launches the smartphone application and inputs their current emotions. The input emotion data (e.g., "happy") and the current date and time are treated as input data. This data is collected through the emotion input screen.

[0653] Step 2:

[0654] The device generates a request including the emotion data entered by the user and the current date and time, and sends it to the server. The data transmission request includes emotion data and time data, and uses JSON as the data format.

[0655] Step 3:

[0656] The server processes the data received from the device and stores it in a database. The received emotion data is recorded in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}. The server checks whether the data was saved successfully and notifies the device of the result.

[0657] Step 4:

[0658] The device receives the notification from the server and displays a confirmation message to the user saying, "Emotions have been recorded." This lets the user know that the input emotion data has been successfully recorded.

[0659] Step 5:

[0660] At the end of the week, users open the application on their smartphone, select the "Weekly Reflection" menu, and tap the "Receive Prompt" button, which generates a request for a reflection prompt.

[0661] Step 6:

[0662] The device sends a request for a reflection prompt to the server, which includes the user's identity and arranges for the server to provide an appropriate prompt for each user.

[0663] Step 7:

[0664] When the server receives a request, it randomly selects one message from the list of reflection messages. The Python random module is used to select the reflection message. The selected message (e.g., "What was the happiest moment of this week?") is generated.

[0665] Step 8:

[0666] The server sends the selected reflection prompt to the terminal. The sent data includes the selected prompt message and uses JSON as the data format.

[0667] Step 9:

[0668] The device displays the reflection prompts received from the server to the user, allowing the user to deepen their self-understanding based on the prompts provided as weekly reflections.

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

[0670] The "Self-Mental Care Coach" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. Furthermore, the present invention combines an emotion engine to recognize the user's emotions and provide more accurate mental care. Specific embodiments of this system will be described below.

[0671] User emotion record

[0672] 1. Display the emotion input screen

[0673] The device starts the application and displays an interface (emotion input screen) for the user to input emotions. The user inputs their current emotion (e.g., "happy," "sad," etc.) in a text field.

[0674] 2. Sending Emotional Data

[0675] After inputting the emotion, the user taps the "Send" button, which sends the emotion data from the device to the server.

[0676] 3. Emotion Data Analysis

[0677] The server analyzes the emotion data received from the device using an emotion engine, which uses natural language processing technology and machine learning algorithms to recognize the user's emotions.

[0678] 4. Storing Emotional Data

[0679] The server records the analyzed emotion data in an emotion log for each user, for example, in the form {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} in the database.

[0680] 5. Recording completion notification

[0681] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions recorded."

[0682] Providing Reflection Messages

[0683] 1. Displaying the reflection screen

[0684] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0685] 2. Request a Reflection Prompt

[0686] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[0687] 3. Select a reflection prompt

[0688] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[0689] 4. Sending a Reflection Prompt

[0690] The server sends the selected reflection prompt to the terminal.

[0691] 5. Displaying the Reflection Prompt

[0692] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[0693] Specific examples

[0694] Examples of emotion recording

[0695] The user opens the application and enters their current emotion, "Happy." When they tap the "Send" button, the device sends the emotion data "Happy" and the current date and time to the server. The server analyzes the received data with its emotion engine and recognizes the emotion "Happy." It then adds this data to the user's emotion log and notifies them that it was successfully recorded. The device displays "Emotion recorded."

[0696] Specific examples of reflection messages

[0697] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[0698] This allows users to efficiently take care of themselves through recording their emotions and weekly reflection. In addition, by utilizing the emotion engine, the system can more accurately recognize users' emotions and provide appropriate feedback.

[0699] The processing flow will be explained below.

[0700] Processing emotion records

[0701] Step 1:

[0702] The terminal displays a screen for the user to input their current emotion. The user inputs their current emotion in a text field.

[0703] Step 2:

[0704] The user can send the emotion they have entered by tapping the "Send" button. This operation sends the emotion data from the device to the server.

[0705] Step 3:

[0706] The terminal generates a request including the emotion data input by the user and the current date and time, and transmits it to the server.

[0707] Step 4:

[0708] The server processes the emotion data received from the device and analyzes it using an emotion engine, which uses natural language processing technology and machine learning algorithms to recognize emotions from the user's text input.

[0709] Step 5:

[0710] The server records the analyzed emotion data in an emotion log for each user, for example, in the form {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} in the database.

[0711] Step 6:

[0712] The server notifies the terminal that the emotion data has been successfully saved.

[0713] Step 7:

[0714] The terminal displays the message "Emotion recorded" to the user, indicating that the emotion has been successfully recorded.

[0715] Providing Reflection Messages

[0716] Step 1:

[0717] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0718] Step 2:

[0719] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[0720] Step 3:

[0721] The terminal sends a request to the server.

[0722] Step 4:

[0723] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[0724] Step 5:

[0725] The server sends the selected reflection prompt to the terminal.

[0726] Step 6:

[0727] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[0728] Specific examples

[0729] Examples of emotion recording

[0730] Step 1:

[0731] The device displays a screen for the user to input an emotion. For example, the user inputs "happy."

[0732] Step 2:

[0733] After entering "happy," the user taps the "Send" button.

[0734] Step 3:

[0735] The terminal generates a request including emotion data "happy" and the current date and time, and sends it to the server.

[0736] Step 4:

[0737] The server receives the emotion data and analyzes it with the emotion engine, which recognizes the emotion "happiness."

[0738] Step 5:

[0739] The server records the recognized emotion data in an emotion log for each user. For example, the data {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} is stored in the database.

[0740] Step 6:

[0741] The server notifies the terminal that the emotion data has been successfully saved.

[0742] Step 7:

[0743] The terminal displays the message "Emotions recorded" to the user.

[0744] Specific examples of reflection messages

[0745] Step 1:

[0746] The terminal displays the "Weekly Reflection" screen to the user.

[0747] Step 2:

[0748] The user taps the "Accept Prompt" button.

[0749] Step 3:

[0750] The terminal sends a request to the server.

[0751] Step 4:

[0752] The server receives the request and randomly selects the message "What was the happiest moment this week?" from the list of reflected messages.

[0753] Step 5:

[0754] The server sends the selected message to the terminal.

[0755] Step 6:

[0756] The device displays the message to the user: "What was the happiest moment this week?"

[0757] This allows users to efficiently take care of themselves through recording their emotions and weekly reflection. In addition, by utilizing the emotion engine, the system can more accurately recognize users' emotions and provide appropriate feedback.

[0758] Example 2

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

[0760] There is a need to provide an efficient means to promote self-understanding and mental health care for users. However, existing methods have the problem of making it difficult for users to accurately record their emotions and receive appropriate feedback based on them. In particular, analyzing emotional data and providing reflection prompts is often done manually, which is time-consuming and labor-intensive, and can have low accuracy.

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

[0762] In this invention, the server includes means for receiving emotion data input by a user, means including a natural language processing engine for analyzing the received emotion data, means for storing the analyzed emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, and means for displaying the selected reflection prompt to the user, thereby enabling the user to conveniently record their emotions and receive appropriate feedback based on the analyzed data.

[0763] "Emotion data" is information about an emotion input by a user, and includes the type of emotion and the date and time when the emotion was recorded.

[0764] A "natural language processing engine" is a computer program for understanding and analyzing human language and is used to automatically recognize emotions.

[0765] "Database" means an information system for storing and managing received and analyzed emotion data, and for efficiently searching and updating the data.

[0766] "Reflection prompts" are questions or messages that encourage self-reflection in users, encouraging them to reflect on their feelings and experiences.

[0767] "Message selection" is the process of randomly choosing an appropriate message from multiple candidates to provide a reflection prompt.

[0768] "Emotion recording" refers to a series of processes that receive emotion data entered by the user, analyze it, and store the analysis results in a database.

[0769] The "Self-Mental Care Coach" system of this invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. Furthermore, the present invention combines an emotion engine to recognize the user's emotions and provide more accurate mental care. Specific embodiments of this system will be described below.

[0770] This system is based on communication between the server, the terminal, and the user. It mainly uses the following main components:

[0771] Hardware and software used

[0772] Servers (e.g., cloud servers or on-premise servers)

[0773] Terminals (mobile devices such as smartphones and tablets)

[0774] A database (e.g., MySQL or MongoDB)

[0775] Natural language processing engines (e.g., BERT models and other machine learning algorithms)

[0776] Applications (mobile applications used by users)

[0777] Key System Features

[0778] 1. Record your emotions

[0779] Phase 1: Application Launch

[0780] When a user launches the application, the device displays an emotion input screen, which includes a text field (for entering emotions) and a "Send" button.

[0781] Phase 2: Enter and send emotion data

[0782] The user inputs their emotion and taps the "Send" button, which sends the emotion data (e.g., "happy," "sad," etc.) and the current date and time from the device to the server.

[0783] Phase 3: Analyzing the emotion data

[0784] The server analyzes the received emotion data using a natural language processing engine, which then analyzes the emotion data and determines which emotion it corresponds to, such as "happy" or "sad."

[0785] Phase 4: Storing Emotional Data

[0786] The server stores the analyzed emotion data in a database as an emotion log for each user, for example, in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[0787] Phase 5: Recording completion notification

[0788] The server notifies the device that the emotion data has been successfully saved, and the device displays a message to the user saying "Emotions recorded."

[0789] 2. Providing reflection prompts

[0790] Step 1: Displaying the reflection screen

[0791] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0792] Phase 2: Request a Reflection Prompt

[0793] The user taps the "Accept Prompt" button, which sends a request from the device to the server.

[0794] Phase 3: Selecting a reflection prompt

[0795] Based on the received request, the server randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[0796] Phase 4: Sending a Reflection Prompt

[0797] The server sends the selected reflection prompt to the terminal.

[0798] Phase 5: Displaying the Reflection Prompt

[0799] The device will then display the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[0800] Specific examples

[0801] Examples of emotion recording

[0802] The user opens the application, enters their current emotion "Happy", and taps the "Send" button. The device sends the emotion data "Happy" and the current date and time to the server via an HTTP POST request. The server analyzes the received data using a natural language processing engine (e.g., the BERT model) and stores the results in a database. Finally, the device displays a message to the user saying "Emotion recorded."

[0803] Specific examples of reflection messages

[0804] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list and sends it to the device. The device then displays this message to the user.

[0805] This system allows users to efficiently take care of themselves through recording and reflecting on their emotions. In addition, by utilizing the emotion engine, the system can more accurately recognize users' emotions and provide appropriate feedback.

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

[0807] Emotion recording processing steps

[0808] Step 1:

[0809] The device launches the application and displays the emotion input screen.

[0810] Specific operation: When a user taps the app icon, the device loads the home screen and displays the emotion input page, which is the input.

[0811] Step 2:

[0812] The user enters their emotion into the input field and taps the "Send" button.

[0813] Specific behavior: When the user enters an emotion, such as "happy," into the text field and taps the "Submit" button, this becomes the input data.

[0814] Step 3:

[0815] The device sends emotion data (e.g., "happy") and the current date and time to the server as an HTTP POST request.

[0816] Specific operation: When the send button is pressed, the device generates JSON format data that combines emotion data and the current date and time, and sends it to the server. The output here is the sent data.

[0817] Step 4:

[0818] The server analyzes the received emotional data using a natural language processing engine.

[0819] Specific operation: The server inputs the received data into an analysis engine (e.g., BERT model) and performs data calculations. The analysis engine analyzes the text data and recognizes the type of emotion. The output is an emotion label based on the analysis result.

[0820] Step 5:

[0821] The server stores the analyzed emotion data in a database for each user.

[0822] Specific operation: The server records the analysis result and timestamp in the database in the format '{time': '2023-10-05 14:23:45', 'emotion': 'happy'}. The input is the analysis result and timestamp, and the output is the saved data.

[0823] Step 6:

[0824] The server notifies the device that the emotion data has been successfully saved, and the device displays a message to the user saying "Emotions recorded."

[0825] Specific behavior: The server returns the save completion status to the device, and the device displays a popup or toast notification. The input here is the save completion status, and the output is the notification displayed to the user.

[0826] Steps for Providing Reflection Prompts

[0827] Step 1:

[0828] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0829] Specific behavior: When a user selects the weekly reflection option from the menu, the device loads and displays the corresponding screen. The input is the user's operation, and the output is the display of the reflection screen.

[0830] Step 2:

[0831] The user taps the "Accept Prompt" button.

[0832] Specific behavior: When the user taps the "Accept Prompt" button, this becomes the input.

[0833] Step 3:

[0834] The terminal sends the request to the server.

[0835] Specific behavior: The request is sent to the server as an HTTP request. The input is the request from the user, and the output is the request sent.

[0836] Step 4:

[0837] Based on the received request, the server randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[0838] Specific behavior: The server randomly selects one from the prompt list and retrieves it. The input is the request and the prompt list, and the output is the selected message.

[0839] Step 5:

[0840] The server sends the selected reflection prompt to the terminal.

[0841] Specific operation: The server returns an HTTP response containing the selected message to the terminal. The input is the selected message, and the output is the HTTP response.

[0842] Step 6:

[0843] The terminal displays the received reflection prompt to the user.

[0844] Specific operation: The terminal displays the received message on the screen and presents it to the user. The input here is the HTTP response, and the output is the prompt message displayed to the user.

[0845] (Application example 2)

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

[0847] Mental health has become a major issue in modern society. It is particularly important for individuals to appropriately manage their emotions and reduce mental stress. However, in busy daily lives, it is difficult to regularly record and analyze emotions, and it is also difficult to respond immediately when excessive stress occurs. There is a need for a system that can solve these problems and efficiently support users' mental health.

[0848] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving emotion data input by the user, means for saving the received emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, and means for notifying an emergency contact when excessive mental stress is detected. This makes it possible to periodically record and analyze the user's emotions, provide feedback at an appropriate time, and respond quickly in an emergency.

[0849] "Emotion data" refers to information relating to emotions input by a user, and is digital information that indicates the user's emotional state.

[0850] A "database" is a system for systematically storing and managing received emotion data, and is an information resource for efficiently managing large amounts of data.

[0851] "Reflection prompts" are messages that encourage users to self-awareness and reflect on their emotions, and are leading questions that allow users to reevaluate their own emotions.

[0852] "Mental stress" refers to a state of psychological or emotional pressure or tension, and refers to the mental burden on the user.

[0853] An "emergency contact" is a contact to be notified when the user experiences excessive mental stress, and is a person to be contacted in an emergency.

[0854] The "Self-Mental Care Guard" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. It also has a function to notify emergency contacts if excessive mental stress is detected. A specific embodiment of this system will be described below.

[0855] User emotion record

[0856] 1. Display the emotion input screen

[0857] The terminal starts the application and displays an interface (emotion input screen) for the user to input emotions.

[0858] The user enters their current emotion (e.g., "happy," "sad," etc.) in a text field.

[0859] 2. Sending Emotional Data

[0860] After inputting the emotion, the user taps the "Send" button, which sends the emotion data from the device to the server.

[0861] 3. Emotion Data Analysis

[0862] The server analyzes the emotion data received from the device using an emotion engine, which uses natural language processing technology and machine learning algorithms to recognize the user's emotions.

[0863] 4. Storing Emotional Data

[0864] The server records the analyzed emotion data in an emotion log for each user, for example, in the form {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} in the database.

[0865] 5. Recording completion notification

[0866] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions recorded."

[0867] Providing Reflection Messages

[0868] 1. Displaying the reflection screen

[0869] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0870] 2. Request a Reflection Prompt

[0871] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[0872] 3. Select a reflection prompt

[0873] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[0874] 4. Sending a Reflection Prompt

[0875] The server sends the selected reflection prompt to the terminal.

[0876] 5. Displaying the Reflection Prompt

[0877] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[0878] Emergency notification function

[0879] 1. Detecting mental stress

[0880] The server analyzes the emotional data and detects if the user's mental stress level is high.

[0881] 2. Notification to emergency contacts

[0882] If an emergency call is deemed necessary, the server sends a notification to the user's designated emergency contacts, including a summary of the user's current mental state.

[0883] Hardware and software used

[0884] Device: Smartphone

[0885] Server: Cloud server (e.g. AWS, Google Cloud)

[0886] Database: SQL database (e.g. MySQL, PostgreSQL)

[0887] Emotion engine: Natural language processing techniques and machine learning algorithms (e.g., Python's NLTK, TensorFlow)

[0888] Communication library: requests library

[0889] Specific examples

[0890] Examples of emotion recording

[0891] The user opens the application and enters their current emotion, "Sad." When they tap the "Send" button, the device sends the emotion data "Sad" and the current date and time to the server. The server analyzes the received data with its emotion engine and recognizes the emotion "Sad." It then adds this data to the user's emotion log and notifies them that it was successfully recorded. The device then displays "Emotion recorded."

[0892] Specific examples of reflection messages

[0893] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[0894] Example of operation

[0895] Prompt Sentence Examples

[0896] "What was your happiest moment this week?"

[0897] By utilizing a generative AI model, we can realize effective self-mental care and support the user's mental health. This system allows users to efficiently practice self-mental care through recording their emotions and weekly reflection. It also enables rapid response in emergencies.

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

[0899] Step 1:

[0900] The device displays an interface (emotion input screen) for the user to input emotions. This interface includes a text field for inputting emotions and a "Send" button. The user enters the current emotion in the text field and taps the "Send" button.

[0901] Input: Emotion data entered by the user

[0902] Output: Emotion data is sent to the device.

[0903] Step 2:

[0904] When the user taps the "Send" button, the device sends the entered emotion data and the current date and time to the server. At this stage, the device packages the emotion data in JSON format or similar and sends it to the server using an HTTP request.

[0905] Input: Emotion data entered into the device and the current date and time

[0906] Output: Emotion data and date and time are sent to the server.

[0907] Step 3:

[0908] The server analyzes the emotion data received from the device. Specifically, an emotion engine running on the server analyzes the received data and recognizes the user's emotion. The emotion engine uses natural language processing technology and machine learning algorithms. Through this analysis, the emotion data is recognized as emotions such as "happy" or "sad."

[0909] Input: Emotion data and date and time sent to the server

[0910] Output: Parsed emotion data

[0911] Step 4:

[0912] The server stores the analyzed emotion data in a database. At this time, the emotion data is recorded as an emotion log for each user. For example, the data is stored in the format {'time': '2023-10-05 14:23:45', 'emotion': 'Happy'}.

[0913] Input: Parsed emotion data

[0914] Output: Emotion data is saved in the database

[0915] Step 5:

[0916] The server notifies the device that the emotion data has been successfully saved. The device then displays a message to the user saying, "Emotions have been recorded." This message lets the user know that their emotion has been recorded.

[0917] Input: Save completion notification from the server

[0918] Output: Display the message "Emotions recorded" on the terminal.

[0919] Step 6:

[0920] The user selects the "Weekly Reflection" menu and taps the "Receive Prompt" button. The device sends a reflection prompt request to the server. The request includes the user ID and reflection prompt request metadata.

[0921] Input: Reflection prompt request from user

[0922] Output: The request is sent to the server

[0923] Step 7:

[0924] When the server receives the request, it randomly selects a prompt from the list of reflection messages. For example, the message "What was the happiest moment of this week?" is selected and sent from the server to the device.

[0925] Input: Reflection prompt request from user

[0926] Output: A randomly chosen reflection message is sent to the terminal.

[0927] Step 8:

[0928] The device displays the reflection prompt received from the server to the user, allowing the user to reflect on their self-awareness and emotions.

[0929] Input: Reflected prompt sent from the server

[0930] Output: A reflection prompt appears in the terminal

[0931] Step 9:

[0932] The server analyzes the emotional data and detects if the user's mental stress level is high. Specifically, it analyzes past emotional logs and detects excessive stress if a certain threshold is exceeded.

[0933] Input: Emotion data stored on the server

[0934] Output: Mental stress level evaluation results

[0935] Step 10:

[0936] If excessive mental stress is detected, the server sends a notification to the user's designated emergency contacts, along with a summary of the user's current mental state.

[0937] Input: Mental stress level assessment results

[0938] Output: Notification sent to emergency contacts

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

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

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

[0942] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0955] The "Self-Mental Care Coach" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. Specific embodiments of this system will be described below.

[0956] User emotion record

[0957] 1. Display the emotion input screen

[0958] The device starts the application and displays an interface (emotion input screen) for the user to input emotions. The user inputs their current emotion (e.g., "happy," "sad," etc.) in a text field.

[0959] 2. Sending Emotional Data

[0960] After entering their emotion, the user taps the "Send" button, which causes the device to request the server to send the emotion data they entered. At the same time, the current date and time are also attached to the request.

[0961] 3. Emotional Data Storage

[0962] The server processes the emotion data received from the device and records it in the user's emotion log (database). For example, the emotion data is saved in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[0963] 4. Recording completion notification

[0964] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions recorded."

[0965] Providing Reflection Messages

[0966] 1. Displaying the reflection screen

[0967] The device displays the reflection screen to the user who selects "Weekly Reflection" from the application menu. The user taps the "Receive Prompt" button.

[0968] 2. Request a Reflection Prompt

[0969] The terminal transmits a request for a reflection prompt from the user to the server.

[0970] 3. Select a reflection prompt

[0971] When the server receives a request, it randomly selects one message from the list of reflected messages, for example a prompt such as "What was the happiest moment of your week?"

[0972] 4. Sending a Reflection Prompt

[0973] The server sends the selected reflection prompt to the terminal, which displays the message to the user.

[0974] Specific examples

[0975] Examples of emotion recording

[0976] The user opens the application and enters their current emotion, "Happy." When they tap the "Send" button, the device sends the emotion data "Happy" and the current date and time to the server. The server adds the received data to the user's emotion log and notifies them that the recording was successful. The device displays "Emotion recorded."

[0977] Specific examples of reflection messages

[0978] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[0979] This allows users to record their daily emotions and deepen self-understanding through weekly reflection, which is expected to enable efficient self-mental care and contribute to improving mental health.

[0980] The processing flow will be explained below.

[0981] Processing emotion records

[0982] Step 1:

[0983] The terminal displays a screen for the user to input an emotion, and the user inputs the current emotion in a text field on the emotion input screen.

[0984] Step 2:

[0985] After inputting the emotion, the user taps the "Send" button, which sends the emotion data from the device to the server.

[0986] Step 3:

[0987] The terminal generates a request including the emotion data input by the user and the current date and time, and transmits it to the server.

[0988] Step 4:

[0989] The server processes the emotion data received from the device, which includes the type of emotion and the recording date and time.

[0990] Step 5:

[0991] The server records the received emotion data in an emotion log for each user. For example, it stores it in a database in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[0992] Step 6:

[0993] The server notifies the terminal that the emotion data has been successfully saved.

[0994] Step 7:

[0995] The terminal displays the message "Emotion recorded" to the user, indicating that the emotion has been successfully recorded.

[0996] Providing Reflection Messages

[0997] Step 1:

[0998] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[0999] Step 2:

[1000] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[1001] Step 3:

[1002] The terminal sends a request for a reflection prompt to the server.

[1003] Step 4:

[1004] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[1005] Step 5:

[1006] The server sends the selected reflection prompt to the terminal.

[1007] Step 6:

[1008] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[1009] This allows users to efficiently take care of themselves mentally through recording their emotions and reflecting on them weekly.

[1010] Example 1

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

[1012] In modern society, stress and anxiety are on the rise, and many people feel the need for mental health care. To address this issue, it is important to help individuals easily record their emotions on a daily basis and understand their own mental state. However, conventional mental health care systems have struggled to provide effective methods for promoting self-understanding in users.

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

[1014] In this invention, the server includes means for receiving emotion data entered by the user, means for saving the received emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, means for displaying the provided message to the user, and means for notifying the user that transmission of the emotion data has been completed. This allows the user to easily record their daily emotions and periodically reflect on them using the prompts, thereby enabling efficient self-understanding and mental care.

[1015] "User" refers to an individual or end user who uses the system.

[1016] "Emotion data" is information about the user's own emotional state that is input by the user, and includes the type of emotion and the date and time when it was recorded.

[1017] A "database" is a system that organizes and stores collected data and manages it so that it can be searched and updated later.

[1018] "Reflection prompts" are questions or messages that are presented periodically to users with the aim of deepening their self-understanding.

[1019] A "message selection means" is a method or algorithm that selects messages from a message list, either randomly or according to specified criteria, to provide a reflection prompt.

[1020] "Means for displaying to the user" refers to the function or method for displaying the selected message and the recorded emotion on the user's terminal.

[1021] "Means for receiving emotion data" refers to the functions and methods for receiving emotion data entered by the user on the server side.

[1022] "Means for storing emotion data" refers to functions and methods for safely and securely recording received emotion data in a database.

[1023] "Means for notifying that transmission of emotion data has been completed" refers to a function or method for notifying the user that emotion data has been successfully transmitted to the server and has been saved.

[1024] The "Self-Mental Care Coach" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. A specific embodiment of this system will be described below.

[1025] User emotion record

[1026] Displaying the emotion input screen

[1027] The device launches the application and displays an interface (emotion input screen) for the user to input emotions. The screen is built using React Native and Swift and includes a text field for inputting emotions and a "Submit" button. The user enters their current emotion (e.g., "happy," "sad," etc.).

[1028] Sending emotional data

[1029] When the user taps the "Send" button, the device sends the entered emotion data and the current date and time to the server using an HTTPS request, including the user authentication token.

[1030] Storing Emotional Data

[1031] The server processes the received emotion data and records it in a database (e.g., PostgreSQL or MongoDB). The data is saved in a format like {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[1032] Recording completion notification

[1033] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions have been recorded."

[1034] Providing Reflection Messages

[1035] Reflection screen display

[1036] When a user selects "Weekly Reflection" from the application menu, the device displays the reflection screen. The user taps the "Receive Prompt" button.

[1037] Request Reflection Prompt

[1038] The terminal sends prompts to the server based on the user's request.

[1039] Selecting a Reflection Prompt

[1040] When the server receives a request, it randomly selects one message from the list of reflected messages, for example the prompt "What was the happiest moment of this week?"

[1041] Sending a Reflection Prompt

[1042] The server sends the selected prompt to the terminal, which displays the message to the user.

[1043] Specific examples

[1044] Examples of emotion recording

[1045] The user opens the application and enters their current emotion, "Happy." When they tap the "Send" button, the device sends the emotion data "Happy" and the current date and time to the server. The server adds the received data to the user's emotion log and notifies them that the recording was successful. The device displays "Emotion recorded."

[1046] Specific examples of reflection messages

[1047] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user. This allows the user to record their daily emotions and deepen self-understanding through weekly reflection.

[1048] Through this series of processes, users will be able to take efficient self-care of their mental health, which is expected to contribute to improving their mental health.

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

[1050] Step 1:

[1051] Displaying the emotion input screen

[1052] When a user launches the application, the device displays an emotion input screen. The screen includes a text field for entering emotions and a "Submit" button. The input is the user's current emotion. The output is the text field with the emotion entered. In concrete terms, the application is built using React Native or Swift, and the user launches the application by tapping the screen.

[1053] Step 2:

[1054] Entering emotion data

[1055] The user enters their emotion (e.g., "happy," "sad," etc.) into a text field on the emotion input screen. As input, the user enters a specific emotion. As output, that emotion is displayed in the text field. Specifically, the user enters their emotion using the keyboard.

[1056] Step 3:

[1057] Sending emotional data

[1058] When the user taps the "Send" button, the device sends the entered emotion data and the current date and time to the server. At this time, the data is sent using an HTTPS request. The inputs are emotion data and the current date and time. The output is sent to the server. Specifically, the device uses JavaScript or Axios to send the emotion data in JSON format.

[1059] Step 4:

[1060] Storing Emotional Data

[1061] The server processes the received emotion data and stores it in a database. PostgreSQL or MongoDB is used as the database. The input is the received emotion data and the current date and time. The output is the data stored in the database. Specifically, the server executes a database operation command to record the emotion data in the database in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[1062] Step 5:

[1063] Recording completion notification

[1064] The server notifies the device that the emotion data has been successfully saved. The input is information that the emotion data has been successfully saved. The output is a notification message to the device. Specifically, the server generates an HTTP response and sends a message to the device saying "Emotions recorded." The device then displays this message to the user.

[1065] Step 6:

[1066] Reflection screen display

[1067] When a user selects "Weekly Reflection" from the application menu, the device displays the reflection screen. The input is the user's selection operation. The output is the display of the reflection screen. In concrete terms, the user operates the screen to select the "Weekly Reflection" menu.

[1068] Step 7:

[1069] Request Reflection Prompt

[1070] When the "Receive Prompt" button is tapped, the device requests a prompt from the server. The input is the user tapping the "Receive Prompt" button. The output is a prompt request to the server. The specific operation is that the device generates an HTTP request and sends it to the server.

[1071] Step 8:

[1072] Selecting a Reflection Prompt

[1073] The server randomly selects one message from the list of reflected messages based on the received request. The input is the request. The output is the selected prompt message. Specifically, the server selects one message from the reflected message list using a random algorithm.

[1074] Step 9:

[1075] Sending a Reflection Prompt

[1076] The server sends the selected prompt to the terminal, and the terminal displays that message to the user. The input is the selected prompt message. The output is the message displayed to the user. In concrete terms, the server sends the prompt message as an HTTP response, and the terminal receives the message and displays it on the reflection screen.

[1077] By following these steps, users can input and record their own emotions and receive periodic reflection prompts. We hope that this system will promote self-understanding and mental health care for users.

[1078] (Application example 1)

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

[1080] In modern workplaces, employee mental health has become a critical issue. In particular, in brick-and-mortar stores such as retail and service industries, employee stress often directly impacts the quality of customer service. Therefore, effective methods for supporting employee mental health and improving the quality of customer service are needed. To address this issue, the present invention aims to provide a system that allows employees to record their daily emotions and periodically provides reflection prompts to deepen self-understanding.

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

[1082] In this invention, the server includes means for receiving emotion data entered by a user, means for storing the received emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, means for displaying the provided message to the user, and means for employees to record their daily work emotions and provide a reflection message each week to promote self-understanding. This allows employees to objectively reflect on their own emotions, deepening self-understanding and improving their mental health, which in turn makes it possible to improve the quality of customer service.

[1083] "Emotion data" is data including the current emotion entered by the user and its details.

[1084] "Reflection prompts" are questions or messages that are periodically provided to users to encourage them to reflect on their own feelings and experiences.

[1085] A "database" is a structured system of record for storing received emotion data.

[1086] A "server" is a computer system on a network that is responsible for receiving and storing emotion data and providing reflection prompts.

[1087] An "emotion input screen" is an interface that allows users to input their own emotions, and is displayed on smartphones and other devices.

[1088] A "random selection method" is an algorithm or method for randomly selecting a reflection prompt or message from a list.

[1089] A "brick and mortar store" is a retail or service establishment that exists in a physical location and is a face-to-face environment between employees and customers.

[1090] "Employees" are workers who deal with customers and perform other tasks in physical stores, and are the recipients of mental health care and who record their emotions during their daily work.

[1091] The "Self Mental Care Coach" system of the present invention provides a mental care application for employees of brick-and-mortar stores. Specific embodiments for carrying out the present invention will be described below.

[1092] Emotion recording function

[1093] Before starting or after work, users launch the smartphone application and input their current emotions. This emotion recording is done from the emotion input screen. The emotion input screen has an intuitive interface designed to allow users to easily input their emotions. For example, users can enter emotions such as "happy" or "sad" in a text field.

[1094] The device sends the emotion data entered by the user and the current date and time to the server. The server stores the received emotion data in a database, for example, in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}. If the emotion data is successfully saved, the server notifies the device, and the device displays "Emotion recorded."

[1095] Reflection prompt function

[1096] At the end of the week, users select "Weekly Reflection" from the application menu and tap the button to receive the prompt. The device then sends a request for a reflection prompt to the server.

[1097] When the server receives the request, it randomly selects one message from the list of reflection messages, for example, "What was the happiest moment of this week?" The server then sends the selected reflection prompt to the device, which displays the message to the user.

[1098] Natural language description of the process

[1099] The main processing of this system involves several pieces of hardware and software. The devices used are mainly smartphones, with the necessary applications for emotion input and prompt display installed. The server uses Flask, a Python microweb framework, to receive and store emotion data and select reflection messages. Emotion data is stored in a simple database, and the Python random module is used to select random prompts.

[1100] Specific examples

[1101] Examples of emotion recording

[1102] The user opens the smartphone application, inputs their current emotion, "Happy," and taps the "Send" button. The device sends the emotion data, "Happy," and the current date and time to the server. The server adds the received data to the user's emotion log and notifies them that the recording was successful. The device displays a notification saying, "Emotion recorded."

[1103] Specific examples of reflection messages

[1104] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[1105] Prompt Sentence Examples

[1106] "What was your happiest moment this week?"

[1107] "What was your most stressful moment this week?"

[1108] "Tell me one thing you learned this week."

[1109] "What did you feel you could improve this week?"

[1110] This system allows employees to record their daily emotions and deepen self-understanding through weekly reflection, which is expected to contribute to improving mental health.

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

[1112] Step 1:

[1113] Before starting work, the user launches the smartphone application and inputs their current emotions. The input emotion data (e.g., "happy") and the current date and time are treated as input data. This data is collected through the emotion input screen.

[1114] Step 2:

[1115] The device generates a request including the emotion data entered by the user and the current date and time, and sends it to the server. The data transmission request includes emotion data and time data, and uses JSON as the data format.

[1116] Step 3:

[1117] The server processes the data received from the device and stores it in a database. The received emotion data is recorded in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}. The server checks whether the data was saved successfully and notifies the device of the result.

[1118] Step 4:

[1119] The device receives the notification from the server and displays a confirmation message to the user saying, "Emotions have been recorded." This lets the user know that the input emotion data has been successfully recorded.

[1120] Step 5:

[1121] At the end of the week, users open the application on their smartphone, select the "Weekly Reflection" menu, and tap the "Receive Prompt" button, which generates a request for a reflection prompt.

[1122] Step 6:

[1123] The device sends a request for a reflection prompt to the server, which includes the user's identity and arranges for the server to provide an appropriate prompt for each user.

[1124] Step 7:

[1125] When the server receives a request, it randomly selects one message from the list of reflection messages. The Python random module is used to select the reflection message. The selected message (e.g., "What was the happiest moment of this week?") is generated.

[1126] Step 8:

[1127] The server sends the selected reflection prompt to the terminal. The sent data includes the selected prompt message and uses JSON as the data format.

[1128] Step 9:

[1129] The device displays the reflection prompts received from the server to the user, allowing the user to deepen their self-understanding based on the prompts provided as weekly reflections.

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

[1131] The "Self-Mental Care Coach" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. Furthermore, the present invention combines an emotion engine to recognize the user's emotions and provide more accurate mental care. Specific embodiments of this system will be described below.

[1132] User emotion record

[1133] 1. Display the emotion input screen

[1134] The device starts the application and displays an interface (emotion input screen) for the user to input emotions. The user inputs their current emotion (e.g., "happy," "sad," etc.) in a text field.

[1135] 2. Sending Emotional Data

[1136] After inputting the emotion, the user taps the "Send" button, which sends the emotion data from the device to the server.

[1137] 3. Emotion Data Analysis

[1138] The server analyzes the emotion data received from the device using an emotion engine, which uses natural language processing technology and machine learning algorithms to recognize the user's emotions.

[1139] 4. Storing Emotional Data

[1140] The server records the analyzed emotion data in an emotion log for each user, for example, in the form {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} in the database.

[1141] 5. Recording completion notification

[1142] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions recorded."

[1143] Providing Reflection Messages

[1144] 1. Displaying the reflection screen

[1145] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[1146] 2. Request a Reflection Prompt

[1147] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[1148] 3. Select a reflection prompt

[1149] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[1150] 4. Sending a Reflection Prompt

[1151] The server sends the selected reflection prompt to the terminal.

[1152] 5. Displaying the Reflection Prompt

[1153] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[1154] Specific examples

[1155] Examples of emotion recording

[1156] The user opens the application and enters their current emotion, "Happy." When they tap the "Send" button, the device sends the emotion data "Happy" and the current date and time to the server. The server analyzes the received data with its emotion engine and recognizes the emotion "Happy." It then adds this data to the user's emotion log and notifies them that it was successfully recorded. The device displays "Emotion recorded."

[1157] Specific examples of reflection messages

[1158] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[1159] This allows users to efficiently take care of themselves through recording their emotions and weekly reflection. In addition, by utilizing the emotion engine, the system can more accurately recognize users' emotions and provide appropriate feedback.

[1160] The processing flow will be explained below.

[1161] Processing emotion records

[1162] Step 1:

[1163] The terminal displays a screen for the user to input their current emotion. The user inputs their current emotion in a text field.

[1164] Step 2:

[1165] The user can send the emotion they have entered by tapping the "Send" button. This operation sends the emotion data from the device to the server.

[1166] Step 3:

[1167] The terminal generates a request including the emotion data input by the user and the current date and time, and transmits it to the server.

[1168] Step 4:

[1169] The server processes the emotion data received from the device and analyzes it using an emotion engine, which uses natural language processing technology and machine learning algorithms to recognize emotions from the user's text input.

[1170] Step 5:

[1171] The server records the analyzed emotion data in an emotion log for each user, for example, in the form {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} in the database.

[1172] Step 6:

[1173] The server notifies the terminal that the emotion data has been successfully saved.

[1174] Step 7:

[1175] The terminal displays the message "Emotion recorded" to the user, indicating that the emotion has been successfully recorded.

[1176] Providing Reflection Messages

[1177] Step 1:

[1178] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[1179] Step 2:

[1180] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[1181] Step 3:

[1182] The terminal sends a request to the server.

[1183] Step 4:

[1184] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[1185] Step 5:

[1186] The server sends the selected reflection prompt to the terminal.

[1187] Step 6:

[1188] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[1189] Specific examples

[1190] Examples of emotion recording

[1191] Step 1:

[1192] The device displays a screen for the user to input an emotion. For example, the user inputs "happy."

[1193] Step 2:

[1194] After entering "happy," the user taps the "Send" button.

[1195] Step 3:

[1196] The terminal generates a request including emotion data "happy" and the current date and time, and sends it to the server.

[1197] Step 4:

[1198] The server receives the emotion data and analyzes it with the emotion engine, which recognizes the emotion "happiness."

[1199] Step 5:

[1200] The server records the recognized emotion data in an emotion log for each user. For example, the data {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} is stored in the database.

[1201] Step 6:

[1202] The server notifies the terminal that the emotion data has been successfully saved.

[1203] Step 7:

[1204] The terminal displays the message "Emotions recorded" to the user.

[1205] Specific examples of reflection messages

[1206] Step 1:

[1207] The terminal displays the "Weekly Reflection" screen to the user.

[1208] Step 2:

[1209] The user taps the "Accept Prompt" button.

[1210] Step 3:

[1211] The terminal sends a request to the server.

[1212] Step 4:

[1213] The server receives the request and randomly selects the message "What was the happiest moment this week?" from the list of reflected messages.

[1214] Step 5:

[1215] The server sends the selected message to the terminal.

[1216] Step 6:

[1217] The device displays the message to the user: "What was the happiest moment this week?"

[1218] This allows users to efficiently take care of themselves through recording their emotions and weekly reflection. In addition, by utilizing the emotion engine, the system can more accurately recognize users' emotions and provide appropriate feedback.

[1219] Example 2

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

[1221] There is a need to provide an efficient means to promote self-understanding and mental health care for users. However, existing methods have the problem of making it difficult for users to accurately record their emotions and receive appropriate feedback based on them. In particular, analyzing emotional data and providing reflection prompts is often done manually, which is time-consuming and labor-intensive, and can have low accuracy.

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

[1223] In this invention, the server includes means for receiving emotion data input by a user, means including a natural language processing engine for analyzing the received emotion data, means for storing the analyzed emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, and means for displaying the selected reflection prompt to the user, thereby enabling the user to conveniently record their emotions and receive appropriate feedback based on the analyzed data.

[1224] "Emotion data" is information about an emotion input by a user, and includes the type of emotion and the date and time when the emotion was recorded.

[1225] A "natural language processing engine" is a computer program for understanding and analyzing human language and is used to automatically recognize emotions.

[1226] "Database" means an information system for storing and managing received and analyzed emotion data, and for efficiently searching and updating the data.

[1227] "Reflection prompts" are questions or messages that encourage self-reflection in users, encouraging them to reflect on their feelings and experiences.

[1228] "Message selection" is the process of randomly choosing an appropriate message from multiple candidates to provide a reflection prompt.

[1229] "Emotion recording" refers to a series of processes that receive emotion data entered by the user, analyze it, and store the analysis results in a database.

[1230] The "Self-Mental Care Coach" system of this invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. Furthermore, the present invention combines an emotion engine to recognize the user's emotions and provide more accurate mental care. Specific embodiments of this system will be described below.

[1231] This system is based on communication between the server, the terminal, and the user. It mainly uses the following main components:

[1232] Hardware and software used

[1233] Servers (e.g., cloud servers or on-premise servers)

[1234] Terminals (mobile devices such as smartphones and tablets)

[1235] A database (e.g., MySQL or MongoDB)

[1236] Natural language processing engines (e.g., BERT models and other machine learning algorithms)

[1237] Applications (mobile applications used by users)

[1238] Key System Features

[1239] 1. Record your emotions

[1240] Phase 1: Application Launch

[1241] When a user launches the application, the device displays an emotion input screen, which includes a text field (for entering emotions) and a "Send" button.

[1242] Phase 2: Enter and send emotion data

[1243] The user inputs their emotion and taps the "Send" button, which sends the emotion data (e.g., "happy," "sad," etc.) and the current date and time from the device to the server.

[1244] Phase 3: Analyzing the emotion data

[1245] The server analyzes the received emotion data using a natural language processing engine, which then analyzes the emotion data and determines which emotion it corresponds to, such as "happy" or "sad."

[1246] Phase 4: Storing Emotional Data

[1247] The server stores the analyzed emotion data in a database as an emotion log for each user, for example, in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[1248] Phase 5: Recording completion notification

[1249] The server notifies the device that the emotion data has been successfully saved, and the device displays a message to the user saying "Emotions recorded."

[1250] 2. Providing reflection prompts

[1251] Step 1: Displaying the reflection screen

[1252] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[1253] Phase 2: Request a Reflection Prompt

[1254] The user taps the "Accept Prompt" button, which sends a request from the device to the server.

[1255] Phase 3: Selecting a reflection prompt

[1256] Based on the received request, the server randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[1257] Phase 4: Sending a Reflection Prompt

[1258] The server sends the selected reflection prompt to the terminal.

[1259] Phase 5: Displaying the Reflection Prompt

[1260] The device will then display the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[1261] Specific examples

[1262] Examples of emotion recording

[1263] The user opens the application, enters their current emotion "Happy", and taps the "Send" button. The device sends the emotion data "Happy" and the current date and time to the server via an HTTP POST request. The server analyzes the received data using a natural language processing engine (e.g., the BERT model) and stores the results in a database. Finally, the device displays a message to the user saying "Emotion recorded."

[1264] Specific examples of reflection messages

[1265] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list and sends it to the device. The device then displays this message to the user.

[1266] This system allows users to efficiently take care of themselves through recording and reflecting on their emotions. In addition, by utilizing the emotion engine, the system can more accurately recognize users' emotions and provide appropriate feedback.

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

[1268] Emotion recording processing steps

[1269] Step 1:

[1270] The device launches the application and displays the emotion input screen.

[1271] Specific operation: When a user taps the app icon, the device loads the home screen and displays the emotion input page, which is the input.

[1272] Step 2:

[1273] The user enters their emotion into the input field and taps the "Send" button.

[1274] Specific behavior: When the user enters an emotion, such as "happy," into the text field and taps the "Submit" button, this becomes the input data.

[1275] Step 3:

[1276] The device sends emotion data (e.g., "happy") and the current date and time to the server as an HTTP POST request.

[1277] Specific operation: When the send button is pressed, the device generates JSON format data that combines emotion data and the current date and time, and sends it to the server. The output here is the sent data.

[1278] Step 4:

[1279] The server analyzes the received emotional data using a natural language processing engine.

[1280] Specific operation: The server inputs the received data into an analysis engine (e.g., BERT model) and performs data calculations. The analysis engine analyzes the text data and recognizes the type of emotion. The output is an emotion label based on the analysis result.

[1281] Step 5:

[1282] The server stores the analyzed emotion data in a database for each user.

[1283] Specific operation: The server records the analysis result and timestamp in the database in the format '{time': '2023-10-05 14:23:45', 'emotion': 'happy'}. The input is the analysis result and timestamp, and the output is the saved data.

[1284] Step 6:

[1285] The server notifies the device that the emotion data has been successfully saved, and the device displays a message to the user saying "Emotions recorded."

[1286] Specific behavior: The server returns the save completion status to the device, and the device displays a popup or toast notification. The input here is the save completion status, and the output is the notification displayed to the user.

[1287] Steps for Providing Reflection Prompts

[1288] Step 1:

[1289] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[1290] Specific behavior: When a user selects the weekly reflection option from the menu, the device loads and displays the corresponding screen. The input is the user's operation, and the output is the display of the reflection screen.

[1291] Step 2:

[1292] The user taps the "Accept Prompt" button.

[1293] Specific behavior: When the user taps the "Accept Prompt" button, this becomes the input.

[1294] Step 3:

[1295] The terminal sends the request to the server.

[1296] Specific behavior: The request is sent to the server as an HTTP request. The input is the request from the user, and the output is the request sent.

[1297] Step 4:

[1298] Based on the received request, the server randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[1299] Specific behavior: The server randomly selects one from the prompt list and retrieves it. The input is the request and the prompt list, and the output is the selected message.

[1300] Step 5:

[1301] The server sends the selected reflection prompt to the terminal.

[1302] Specific operation: The server returns an HTTP response containing the selected message to the terminal. The input is the selected message, and the output is the HTTP response.

[1303] Step 6:

[1304] The terminal displays the received reflection prompt to the user.

[1305] Specific operation: The terminal displays the received message on the screen and presents it to the user. The input here is the HTTP response, and the output is the prompt message displayed to the user.

[1306] (Application example 2)

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

[1308] Mental health has become a major issue in modern society. It is particularly important for individuals to appropriately manage their emotions and reduce mental stress. However, in busy daily lives, it is difficult to regularly record and analyze emotions, and it is also difficult to respond immediately when excessive stress occurs. There is a need for a system that can solve these problems and efficiently support users' mental health.

[1309] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving emotion data input by the user, means for saving the received emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, and means for notifying an emergency contact when excessive mental stress is detected. This makes it possible to periodically record and analyze the user's emotions, provide feedback at an appropriate time, and respond quickly in an emergency.

[1310] "Emotion data" refers to information relating to emotions input by a user, and is digital information that indicates the user's emotional state.

[1311] A "database" is a system for systematically storing and managing received emotion data, and is an information resource for efficiently managing large amounts of data.

[1312] "Reflection prompts" are messages that encourage users to self-awareness and reflect on their emotions, and are leading questions that allow users to reevaluate their own emotions.

[1313] "Mental stress" refers to a state of psychological or emotional pressure or tension, and refers to the mental burden on the user.

[1314] An "emergency contact" is a contact to be notified when the user experiences excessive mental stress, and is a person to be contacted in an emergency.

[1315] The "Self-Mental Care Guard" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. It also has a function to notify emergency contacts if excessive mental stress is detected. A specific embodiment of this system will be described below.

[1316] User emotion record

[1317] 1. Display the emotion input screen

[1318] The terminal starts the application and displays an interface (emotion input screen) for the user to input emotions.

[1319] The user enters their current emotion (e.g., "happy," "sad," etc.) in a text field.

[1320] 2. Sending Emotional Data

[1321] After inputting the emotion, the user taps the "Send" button, which sends the emotion data from the device to the server.

[1322] 3. Emotion Data Analysis

[1323] The server analyzes the emotion data received from the device using an emotion engine, which uses natural language processing technology and machine learning algorithms to recognize the user's emotions.

[1324] 4. Storing Emotional Data

[1325] The server records the analyzed emotion data in an emotion log for each user, for example, in the form {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} in the database.

[1326] 5. Recording completion notification

[1327] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions recorded."

[1328] Providing Reflection Messages

[1329] 1. Displaying the reflection screen

[1330] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[1331] 2. Request a Reflection Prompt

[1332] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[1333] 3. Select a reflection prompt

[1334] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[1335] 4. Sending a Reflection Prompt

[1336] The server sends the selected reflection prompt to the terminal.

[1337] 5. Displaying the Reflection Prompt

[1338] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[1339] Emergency notification function

[1340] 1. Detecting mental stress

[1341] The server analyzes the emotional data and detects if the user's mental stress level is high.

[1342] 2. Notification to emergency contacts

[1343] If an emergency call is deemed necessary, the server sends a notification to the user's designated emergency contacts, including a summary of the user's current mental state.

[1344] Hardware and software used

[1345] Device: Smartphone

[1346] Server: Cloud server (e.g. AWS, Google Cloud)

[1347] Database: SQL database (e.g. MySQL, PostgreSQL)

[1348] Emotion engine: Natural language processing techniques and machine learning algorithms (e.g., Python's NLTK, TensorFlow)

[1349] Communication library: requests library

[1350] Specific examples

[1351] Examples of emotion recording

[1352] The user opens the application and enters their current emotion, "Sad." When they tap the "Send" button, the device sends the emotion data "Sad" and the current date and time to the server. The server analyzes the received data with its emotion engine and recognizes the emotion "Sad." It then adds this data to the user's emotion log and notifies them that it was successfully recorded. The device then displays "Emotion recorded."

[1353] Specific examples of reflection messages

[1354] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[1355] Example of operation

[1356] Prompt Sentence Examples

[1357] "What was your happiest moment this week?"

[1358] By utilizing a generative AI model, we can realize effective self-mental care and support the user's mental health. This system allows users to efficiently practice self-mental care through recording their emotions and weekly reflection. It also enables rapid response in emergencies.

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

[1360] Step 1:

[1361] The device displays an interface (emotion input screen) for the user to input emotions. This interface includes a text field for inputting emotions and a "Send" button. The user enters the current emotion in the text field and taps the "Send" button.

[1362] Input: Emotion data entered by the user

[1363] Output: Emotion data is sent to the device.

[1364] Step 2:

[1365] When the user taps the "Send" button, the device sends the entered emotion data and the current date and time to the server. At this stage, the device packages the emotion data in JSON format or similar and sends it to the server using an HTTP request.

[1366] Input: Emotion data entered into the device and the current date and time

[1367] Output: Emotion data and date and time are sent to the server.

[1368] Step 3:

[1369] The server analyzes the emotion data received from the device. Specifically, an emotion engine running on the server analyzes the received data and recognizes the user's emotion. The emotion engine uses natural language processing technology and machine learning algorithms. Through this analysis, the emotion data is recognized as emotions such as "happy" or "sad."

[1370] Input: Emotion data and date and time sent to the server

[1371] Output: Parsed emotion data

[1372] Step 4:

[1373] The server stores the analyzed emotion data in a database. At this time, the emotion data is recorded as an emotion log for each user. For example, the data is stored in the format {'time': '2023-10-05 14:23:45', 'emotion': 'Happy'}.

[1374] Input: Parsed emotion data

[1375] Output: Emotion data is saved in the database

[1376] Step 5:

[1377] The server notifies the device that the emotion data has been successfully saved. The device then displays a message to the user saying, "Emotions have been recorded." This message lets the user know that their emotion has been recorded.

[1378] Input: Save completion notification from the server

[1379] Output: Display the message "Emotions recorded" on the terminal.

[1380] Step 6:

[1381] The user selects the "Weekly Reflection" menu and taps the "Receive Prompt" button. The device sends a reflection prompt request to the server. The request includes the user ID and reflection prompt request metadata.

[1382] Input: Reflection prompt request from user

[1383] Output: The request is sent to the server

[1384] Step 7:

[1385] When the server receives the request, it randomly selects a prompt from the list of reflection messages. For example, the message "What was the happiest moment of this week?" is selected and sent from the server to the device.

[1386] Input: Reflection prompt request from user

[1387] Output: A randomly chosen reflection message is sent to the terminal.

[1388] Step 8:

[1389] The device displays the reflection prompt received from the server to the user, allowing the user to reflect on their self-awareness and emotions.

[1390] Input: Reflected prompt sent from the server

[1391] Output: A reflection prompt appears in the terminal

[1392] Step 9:

[1393] The server analyzes the emotional data and detects if the user's mental stress level is high. Specifically, it analyzes past emotional logs and detects excessive stress if a certain threshold is exceeded.

[1394] Input: Emotion data stored on the server

[1395] Output: Mental stress level evaluation results

[1396] Step 10:

[1397] If excessive mental stress is detected, the server sends a notification to the user's designated emergency contacts, along with a summary of the user's current mental state.

[1398] Input: Mental stress level assessment results

[1399] Output: Notification sent to emergency contacts

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

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

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

[1403] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1417] The "Self-Mental Care Coach" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. Specific embodiments of this system will be described below.

[1418] User emotion record

[1419] 1. Display the emotion input screen

[1420] The device starts the application and displays an interface (emotion input screen) for the user to input emotions. The user inputs their current emotion (e.g., "happy," "sad," etc.) in a text field.

[1421] 2. Sending Emotional Data

[1422] After entering their emotion, the user taps the "Send" button, which causes the device to request the server to send the emotion data they entered. At the same time, the current date and time are also attached to the request.

[1423] 3. Emotional Data Storage

[1424] The server processes the emotion data received from the device and records it in the user's emotion log (database). For example, the emotion data is saved in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[1425] 4. Recording completion notification

[1426] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions recorded."

[1427] Providing Reflection Messages

[1428] 1. Displaying the reflection screen

[1429] The device displays the reflection screen to the user who selects "Weekly Reflection" from the application menu. The user taps the "Receive Prompt" button.

[1430] 2. Request a Reflection Prompt

[1431] The terminal transmits a request for a reflection prompt from the user to the server.

[1432] 3. Select a reflection prompt

[1433] When the server receives a request, it randomly selects one message from the list of reflected messages, for example a prompt such as "What was the happiest moment of your week?"

[1434] 4. Sending a Reflection Prompt

[1435] The server sends the selected reflection prompt to the terminal, which displays the message to the user.

[1436] Specific examples

[1437] Examples of emotion recording

[1438] The user opens the application and enters their current emotion, "Happy." When they tap the "Send" button, the device sends the emotion data "Happy" and the current date and time to the server. The server adds the received data to the user's emotion log and notifies them that the recording was successful. The device displays "Emotion recorded."

[1439] Specific examples of reflection messages

[1440] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[1441] This allows users to record their daily emotions and deepen self-understanding through weekly reflection, which is expected to enable efficient self-mental care and contribute to improving mental health.

[1442] The processing flow will be explained below.

[1443] Processing emotion records

[1444] Step 1:

[1445] The terminal displays a screen for the user to input an emotion, and the user inputs the current emotion in a text field on the emotion input screen.

[1446] Step 2:

[1447] After inputting the emotion, the user taps the "Send" button, which sends the emotion data from the device to the server.

[1448] Step 3:

[1449] The terminal generates a request including the emotion data input by the user and the current date and time, and transmits it to the server.

[1450] Step 4:

[1451] The server processes the emotion data received from the device, which includes the type of emotion and the recording date and time.

[1452] Step 5:

[1453] The server records the received emotion data in an emotion log for each user. For example, it stores it in a database in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[1454] Step 6:

[1455] The server notifies the terminal that the emotion data has been successfully saved.

[1456] Step 7:

[1457] The terminal displays the message "Emotion recorded" to the user, indicating that the emotion has been successfully recorded.

[1458] Providing Reflection Messages

[1459] Step 1:

[1460] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[1461] Step 2:

[1462] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[1463] Step 3:

[1464] The terminal sends a request for a reflection prompt to the server.

[1465] Step 4:

[1466] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[1467] Step 5:

[1468] The server sends the selected reflection prompt to the terminal.

[1469] Step 6:

[1470] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[1471] This allows users to efficiently take care of themselves mentally through recording their emotions and reflecting on them weekly.

[1472] Example 1

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

[1474] In modern society, stress and anxiety are on the rise, and many people feel the need for mental health care. To address this issue, it is important to help individuals easily record their emotions on a daily basis and understand their own mental state. However, conventional mental health care systems have struggled to provide effective methods for promoting self-understanding in users.

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

[1476] In this invention, the server includes means for receiving emotion data entered by the user, means for saving the received emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, means for displaying the provided message to the user, and means for notifying the user that transmission of the emotion data has been completed. This allows the user to easily record their daily emotions and periodically reflect on them using the prompts, thereby enabling efficient self-understanding and mental care.

[1477] "User" refers to an individual or end user who uses the system.

[1478] "Emotion data" is information about the user's own emotional state that is input by the user, and includes the type of emotion and the date and time when it was recorded.

[1479] A "database" is a system that organizes and stores collected data and manages it so that it can be searched and updated later.

[1480] "Reflection prompts" are questions or messages that are presented periodically to users with the aim of deepening their self-understanding.

[1481] A "message selection means" is a method or algorithm that selects messages from a message list, either randomly or according to specified criteria, to provide a reflection prompt.

[1482] "Means for displaying to the user" refers to the function or method for displaying the selected message and the recorded emotion on the user's terminal.

[1483] "Means for receiving emotion data" refers to the functions and methods for receiving emotion data entered by the user on the server side.

[1484] "Means for storing emotion data" refers to functions and methods for safely and securely recording received emotion data in a database.

[1485] "Means for notifying that transmission of emotion data has been completed" refers to a function or method for notifying the user that emotion data has been successfully transmitted to the server and has been saved.

[1486] The "Self-Mental Care Coach" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. A specific embodiment of this system will be described below.

[1487] User emotion record

[1488] Displaying the emotion input screen

[1489] The device launches the application and displays an interface (emotion input screen) for the user to input emotions. The screen is built using React Native and Swift and includes a text field for inputting emotions and a "Submit" button. The user enters their current emotion (e.g., "happy," "sad," etc.).

[1490] Sending emotional data

[1491] When the user taps the "Send" button, the device sends the entered emotion data and the current date and time to the server using an HTTPS request, including the user authentication token.

[1492] Storing Emotional Data

[1493] The server processes the received emotion data and records it in a database (e.g., PostgreSQL or MongoDB). The data is saved in a format like {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[1494] Recording completion notification

[1495] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions have been recorded."

[1496] Providing Reflection Messages

[1497] Reflection screen display

[1498] When a user selects "Weekly Reflection" from the application menu, the device displays the reflection screen. The user taps the "Receive Prompt" button.

[1499] Request Reflection Prompt

[1500] The terminal sends prompts to the server based on the user's request.

[1501] Selecting a Reflection Prompt

[1502] When the server receives a request, it randomly selects one message from the list of reflected messages, for example the prompt "What was the happiest moment of this week?"

[1503] Sending a Reflection Prompt

[1504] The server sends the selected prompt to the terminal, which displays the message to the user.

[1505] Specific examples

[1506] Examples of emotion recording

[1507] The user opens the application and enters their current emotion, "Happy." When they tap the "Send" button, the device sends the emotion data "Happy" and the current date and time to the server. The server adds the received data to the user's emotion log and notifies them that the recording was successful. The device displays "Emotion recorded."

[1508] Specific examples of reflection messages

[1509] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user. This allows the user to record their daily emotions and deepen self-understanding through weekly reflection.

[1510] Through this series of processes, users will be able to take efficient self-care of their mental health, which is expected to contribute to improving their mental health.

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

[1512] Step 1:

[1513] Displaying the emotion input screen

[1514] When a user launches the application, the device displays an emotion input screen. The screen includes a text field for entering emotions and a "Submit" button. The input is the user's current emotion. The output is the text field with the emotion entered. In concrete terms, the application is built using React Native or Swift, and the user launches the application by tapping the screen.

[1515] Step 2:

[1516] Entering emotion data

[1517] The user enters their emotion (e.g., "happy," "sad," etc.) into a text field on the emotion input screen. As input, the user enters a specific emotion. As output, that emotion is displayed in the text field. Specifically, the user enters their emotion using the keyboard.

[1518] Step 3:

[1519] Sending emotional data

[1520] When the user taps the "Send" button, the device sends the entered emotion data and the current date and time to the server. At this time, the data is sent using an HTTPS request. The inputs are emotion data and the current date and time. The output is sent to the server. Specifically, the device uses JavaScript or Axios to send the emotion data in JSON format.

[1521] Step 4:

[1522] Storing Emotional Data

[1523] The server processes the received emotion data and stores it in a database. PostgreSQL or MongoDB is used as the database. The input is the received emotion data and the current date and time. The output is the data stored in the database. Specifically, the server executes a database operation command to record the emotion data in the database in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[1524] Step 5:

[1525] Recording completion notification

[1526] The server notifies the device that the emotion data has been successfully saved. The input is information that the emotion data has been successfully saved. The output is a notification message to the device. Specifically, the server generates an HTTP response and sends a message to the device saying "Emotions recorded." The device then displays this message to the user.

[1527] Step 6:

[1528] Reflection screen display

[1529] When a user selects "Weekly Reflection" from the application menu, the device displays the reflection screen. The input is the user's selection operation. The output is the display of the reflection screen. In concrete terms, the user operates the screen to select the "Weekly Reflection" menu.

[1530] Step 7:

[1531] Request Reflection Prompt

[1532] When the "Receive Prompt" button is tapped, the device requests a prompt from the server. The input is the user tapping the "Receive Prompt" button. The output is a prompt request to the server. The specific operation is that the device generates an HTTP request and sends it to the server.

[1533] Step 8:

[1534] Selecting a Reflection Prompt

[1535] The server randomly selects one message from the list of reflected messages based on the received request. The input is the request. The output is the selected prompt message. Specifically, the server selects one message from the reflected message list using a random algorithm.

[1536] Step 9:

[1537] Sending a Reflection Prompt

[1538] The server sends the selected prompt to the terminal, and the terminal displays that message to the user. The input is the selected prompt message. The output is the message displayed to the user. In concrete terms, the server sends the prompt message as an HTTP response, and the terminal receives the message and displays it on the reflection screen.

[1539] By following these steps, users can input and record their own emotions and receive periodic reflection prompts. We hope that this system will promote self-understanding and mental health care for users.

[1540] (Application example 1)

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

[1542] In modern workplaces, employee mental health has become a critical issue. In particular, in brick-and-mortar stores such as retail and service industries, employee stress often directly impacts the quality of customer service. Therefore, effective methods for supporting employee mental health and improving the quality of customer service are needed. To address this issue, the present invention aims to provide a system that allows employees to record their daily emotions and periodically provides reflection prompts to deepen self-understanding.

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

[1544] In this invention, the server includes means for receiving emotion data entered by a user, means for storing the received emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, means for displaying the provided message to the user, and means for employees to record their daily work emotions and provide a reflection message each week to promote self-understanding. This allows employees to objectively reflect on their own emotions, deepening self-understanding and improving their mental health, which in turn makes it possible to improve the quality of customer service.

[1545] "Emotion data" is data including the current emotion entered by the user and its details.

[1546] "Reflection prompts" are questions or messages that are periodically provided to users to encourage them to reflect on their own feelings and experiences.

[1547] A "database" is a structured system of record for storing received emotion data.

[1548] A "server" is a computer system on a network that is responsible for receiving and storing emotion data and providing reflection prompts.

[1549] An "emotion input screen" is an interface that allows users to input their own emotions, and is displayed on smartphones and other devices.

[1550] A "random selection method" is an algorithm or method for randomly selecting a reflection prompt or message from a list.

[1551] A "brick and mortar store" is a retail or service establishment that exists in a physical location and is a face-to-face environment between employees and customers.

[1552] "Employees" are workers who deal with customers and perform other tasks in physical stores, and are the recipients of mental health care and who record their emotions during their daily work.

[1553] The "Self Mental Care Coach" system of the present invention provides a mental care application for employees of brick-and-mortar stores. Specific embodiments for carrying out the present invention will be described below.

[1554] Emotion recording function

[1555] Before starting or after work, users launch the smartphone application and input their current emotions. This emotion recording is done from the emotion input screen. The emotion input screen has an intuitive interface designed to allow users to easily input their emotions. For example, users can enter emotions such as "happy" or "sad" in a text field.

[1556] The device sends the emotion data entered by the user and the current date and time to the server. The server stores the received emotion data in a database, for example, in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}. If the emotion data is successfully saved, the server notifies the device, and the device displays "Emotion recorded."

[1557] Reflection prompt function

[1558] At the end of the week, users select "Weekly Reflection" from the application menu and tap the button to receive the prompt. The device then sends a request for a reflection prompt to the server.

[1559] When the server receives the request, it randomly selects one message from the list of reflection messages, for example, "What was the happiest moment of this week?" The server then sends the selected reflection prompt to the device, which displays the message to the user.

[1560] Natural language description of the process

[1561] The main processing of this system involves several pieces of hardware and software. The devices used are mainly smartphones, with the necessary applications for emotion input and prompt display installed. The server uses Flask, a Python microweb framework, to receive and store emotion data and select reflection messages. Emotion data is stored in a simple database, and the Python random module is used to select random prompts.

[1562] Specific examples

[1563] Examples of emotion recording

[1564] The user opens the smartphone application, inputs their current emotion, "Happy," and taps the "Send" button. The device sends the emotion data, "Happy," and the current date and time to the server. The server adds the received data to the user's emotion log and notifies them that the recording was successful. The device displays a notification saying, "Emotion recorded."

[1565] Specific examples of reflection messages

[1566] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[1567] Prompt Sentence Examples

[1568] "What was your happiest moment this week?"

[1569] "What was your most stressful moment this week?"

[1570] "Tell me one thing you learned this week."

[1571] "What did you feel you could improve this week?"

[1572] This system allows employees to record their daily emotions and deepen self-understanding through weekly reflection, which is expected to contribute to improving mental health.

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

[1574] Step 1:

[1575] Before starting work, the user launches the smartphone application and inputs their current emotions. The input emotion data (e.g., "happy") and the current date and time are treated as input data. This data is collected through the emotion input screen.

[1576] Step 2:

[1577] The device generates a request including the emotion data entered by the user and the current date and time, and sends it to the server. The data transmission request includes emotion data and time data, and uses JSON as the data format.

[1578] Step 3:

[1579] The server processes the data received from the device and stores it in a database. The received emotion data is recorded in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}. The server checks whether the data was saved successfully and notifies the device of the result.

[1580] Step 4:

[1581] The device receives the notification from the server and displays a confirmation message to the user saying, "Emotions have been recorded." This lets the user know that the input emotion data has been successfully recorded.

[1582] Step 5:

[1583] At the end of the week, users open the application on their smartphone, select the "Weekly Reflection" menu, and tap the "Receive Prompt" button, which generates a request for a reflection prompt.

[1584] Step 6:

[1585] The device sends a request for a reflection prompt to the server, which includes the user's identity and arranges for the server to provide an appropriate prompt for each user.

[1586] Step 7:

[1587] When the server receives a request, it randomly selects one message from the list of reflection messages. The Python random module is used to select the reflection message. The selected message (e.g., "What was the happiest moment of this week?") is generated.

[1588] Step 8:

[1589] The server sends the selected reflection prompt to the terminal. The sent data includes the selected prompt message and uses JSON as the data format.

[1590] Step 9:

[1591] The device displays the reflection prompts received from the server to the user, allowing the user to deepen their self-understanding based on the prompts provided as weekly reflections.

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

[1593] The "Self-Mental Care Coach" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. Furthermore, the present invention combines an emotion engine to recognize the user's emotions and provide more accurate mental care. Specific embodiments of this system will be described below.

[1594] User emotion record

[1595] 1. Display the emotion input screen

[1596] The device starts the application and displays an interface (emotion input screen) for the user to input emotions. The user inputs their current emotion (e.g., "happy," "sad," etc.) in a text field.

[1597] 2. Sending Emotional Data

[1598] After inputting the emotion, the user taps the "Send" button, which sends the emotion data from the device to the server.

[1599] 3. Emotion Data Analysis

[1600] The server analyzes the emotion data received from the device using an emotion engine, which uses natural language processing technology and machine learning algorithms to recognize the user's emotions.

[1601] 4. Storing Emotional Data

[1602] The server records the analyzed emotion data in an emotion log for each user, for example, in the form {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} in the database.

[1603] 5. Recording completion notification

[1604] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions recorded."

[1605] Providing Reflection Messages

[1606] 1. Displaying the reflection screen

[1607] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[1608] 2. Request a Reflection Prompt

[1609] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[1610] 3. Select a reflection prompt

[1611] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[1612] 4. Sending a Reflection Prompt

[1613] The server sends the selected reflection prompt to the terminal.

[1614] 5. Displaying the Reflection Prompt

[1615] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[1616] Specific examples

[1617] Examples of emotion recording

[1618] The user opens the application and enters their current emotion, "Happy." When they tap the "Send" button, the device sends the emotion data "Happy" and the current date and time to the server. The server analyzes the received data with its emotion engine and recognizes the emotion "Happy." It then adds this data to the user's emotion log and notifies them that it was successfully recorded. The device displays "Emotion recorded."

[1619] Specific examples of reflection messages

[1620] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[1621] This allows users to efficiently take care of themselves through recording their emotions and weekly reflection. In addition, by utilizing the emotion engine, the system can more accurately recognize users' emotions and provide appropriate feedback.

[1622] The processing flow will be explained below.

[1623] Processing emotion records

[1624] Step 1:

[1625] The terminal displays a screen for the user to input their current emotion. The user inputs their current emotion in a text field.

[1626] Step 2:

[1627] The user can send the emotion they have entered by tapping the "Send" button. This operation sends the emotion data from the device to the server.

[1628] Step 3:

[1629] The terminal generates a request including the emotion data input by the user and the current date and time, and transmits it to the server.

[1630] Step 4:

[1631] The server processes the emotion data received from the device and analyzes it using an emotion engine, which uses natural language processing technology and machine learning algorithms to recognize emotions from the user's text input.

[1632] Step 5:

[1633] The server records the analyzed emotion data in an emotion log for each user, for example, in the form {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} in the database.

[1634] Step 6:

[1635] The server notifies the terminal that the emotion data has been successfully saved.

[1636] Step 7:

[1637] The terminal displays the message "Emotion recorded" to the user, indicating that the emotion has been successfully recorded.

[1638] Providing Reflection Messages

[1639] Step 1:

[1640] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[1641] Step 2:

[1642] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[1643] Step 3:

[1644] The terminal sends a request to the server.

[1645] Step 4:

[1646] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[1647] Step 5:

[1648] The server sends the selected reflection prompt to the terminal.

[1649] Step 6:

[1650] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[1651] Specific examples

[1652] Examples of emotion recording

[1653] Step 1:

[1654] The device displays a screen for the user to input an emotion. For example, the user inputs "happy."

[1655] Step 2:

[1656] After entering "happy," the user taps the "Send" button.

[1657] Step 3:

[1658] The terminal generates a request including emotion data "happy" and the current date and time, and sends it to the server.

[1659] Step 4:

[1660] The server receives the emotion data and analyzes it with the emotion engine, which recognizes the emotion "happiness."

[1661] Step 5:

[1662] The server records the recognized emotion data in an emotion log for each user. For example, the data {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} is stored in the database.

[1663] Step 6:

[1664] The server notifies the terminal that the emotion data has been successfully saved.

[1665] Step 7:

[1666] The terminal displays the message "Emotions recorded" to the user.

[1667] Specific examples of reflection messages

[1668] Step 1:

[1669] The terminal displays the "Weekly Reflection" screen to the user.

[1670] Step 2:

[1671] The user taps the "Accept Prompt" button.

[1672] Step 3:

[1673] The terminal sends a request to the server.

[1674] Step 4:

[1675] The server receives the request and randomly selects the message "What was the happiest moment this week?" from the list of reflected messages.

[1676] Step 5:

[1677] The server sends the selected message to the terminal.

[1678] Step 6:

[1679] The device displays the message to the user: "What was the happiest moment this week?"

[1680] This allows users to efficiently take care of themselves through recording their emotions and weekly reflection. In addition, by utilizing the emotion engine, the system can more accurately recognize users' emotions and provide appropriate feedback.

[1681] Example 2

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

[1683] There is a need to provide an efficient means to promote self-understanding and mental health care for users. However, existing methods have the problem of making it difficult for users to accurately record their emotions and receive appropriate feedback based on them. In particular, analyzing emotional data and providing reflection prompts is often done manually, which is time-consuming and labor-intensive, and can have low accuracy.

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

[1685] In this invention, the server includes means for receiving emotion data input by a user, means including a natural language processing engine for analyzing the received emotion data, means for storing the analyzed emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, and means for displaying the selected reflection prompt to the user, thereby enabling the user to conveniently record their emotions and receive appropriate feedback based on the analyzed data.

[1686] "Emotion data" is information about an emotion input by a user, and includes the type of emotion and the date and time when the emotion was recorded.

[1687] A "natural language processing engine" is a computer program for understanding and analyzing human language and is used to automatically recognize emotions.

[1688] "Database" means an information system for storing and managing received and analyzed emotion data, and for efficiently searching and updating the data.

[1689] "Reflection prompts" are questions or messages that encourage self-reflection in users, encouraging them to reflect on their feelings and experiences.

[1690] "Message selection" is the process of randomly choosing an appropriate message from multiple candidates to provide a reflection prompt.

[1691] "Emotion recording" refers to a series of processes that receive emotion data entered by the user, analyze it, and store the analysis results in a database.

[1692] The "Self-Mental Care Coach" system of this invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. Furthermore, the present invention combines an emotion engine to recognize the user's emotions and provide more accurate mental care. Specific embodiments of this system will be described below.

[1693] This system is based on communication between the server, the terminal, and the user. It mainly uses the following main components:

[1694] Hardware and software used

[1695] Servers (e.g., cloud servers or on-premise servers)

[1696] Terminals (mobile devices such as smartphones and tablets)

[1697] A database (e.g., MySQL or MongoDB)

[1698] Natural language processing engines (e.g., BERT models and other machine learning algorithms)

[1699] Applications (mobile applications used by users)

[1700] Key System Features

[1701] 1. Record your emotions

[1702] Phase 1: Application Launch

[1703] When a user launches the application, the device displays an emotion input screen, which includes a text field (for entering emotions) and a "Send" button.

[1704] Phase 2: Enter and send emotion data

[1705] The user inputs their emotion and taps the "Send" button, which sends the emotion data (e.g., "happy," "sad," etc.) and the current date and time from the device to the server.

[1706] Phase 3: Analyzing the emotion data

[1707] The server analyzes the received emotion data using a natural language processing engine, which then analyzes the emotion data and determines which emotion it corresponds to, such as "happy" or "sad."

[1708] Phase 4: Storing Emotional Data

[1709] The server stores the analyzed emotion data in a database as an emotion log for each user, for example, in the format {'time': '2023-10-05 14:23:45', 'emotion': 'happy'}.

[1710] Phase 5: Recording completion notification

[1711] The server notifies the device that the emotion data has been successfully saved, and the device displays a message to the user saying "Emotions recorded."

[1712] 2. Providing reflection prompts

[1713] Step 1: Displaying the reflection screen

[1714] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[1715] Phase 2: Request a Reflection Prompt

[1716] The user taps the "Accept Prompt" button, which sends a request from the device to the server.

[1717] Phase 3: Selecting a reflection prompt

[1718] Based on the received request, the server randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[1719] Phase 4: Sending a Reflection Prompt

[1720] The server sends the selected reflection prompt to the terminal.

[1721] Phase 5: Displaying the Reflection Prompt

[1722] The device will then display the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[1723] Specific examples

[1724] Examples of emotion recording

[1725] The user opens the application, enters their current emotion "Happy", and taps the "Send" button. The device sends the emotion data "Happy" and the current date and time to the server via an HTTP POST request. The server analyzes the received data using a natural language processing engine (e.g., the BERT model) and stores the results in a database. Finally, the device displays a message to the user saying "Emotion recorded."

[1726] Specific examples of reflection messages

[1727] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list and sends it to the device. The device then displays this message to the user.

[1728] This system allows users to efficiently take care of themselves through recording and reflecting on their emotions. In addition, by utilizing the emotion engine, the system can more accurately recognize users' emotions and provide appropriate feedback.

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

[1730] Emotion recording processing steps

[1731] Step 1:

[1732] The device launches the application and displays the emotion input screen.

[1733] Specific operation: When a user taps the app icon, the device loads the home screen and displays the emotion input page, which is the input.

[1734] Step 2:

[1735] The user enters their emotion into the input field and taps the "Send" button.

[1736] Specific behavior: When the user enters an emotion, such as "happy," into the text field and taps the "Submit" button, this becomes the input data.

[1737] Step 3:

[1738] The device sends emotion data (e.g., "happy") and the current date and time to the server as an HTTP POST request.

[1739] Specific operation: When the send button is pressed, the device generates JSON format data that combines emotion data and the current date and time, and sends it to the server. The output here is the sent data.

[1740] Step 4:

[1741] The server analyzes the received emotional data using a natural language processing engine.

[1742] Specific operation: The server inputs the received data into an analysis engine (e.g., BERT model) and performs data calculations. The analysis engine analyzes the text data and recognizes the type of emotion. The output is an emotion label based on the analysis result.

[1743] Step 5:

[1744] The server stores the analyzed emotion data in a database for each user.

[1745] Specific operation: The server records the analysis result and timestamp in the database in the format '{time': '2023-10-05 14:23:45', 'emotion': 'happy'}. The input is the analysis result and timestamp, and the output is the saved data.

[1746] Step 6:

[1747] The server notifies the device that the emotion data has been successfully saved, and the device displays a message to the user saying "Emotions recorded."

[1748] Specific behavior: The server returns the save completion status to the device, and the device displays a popup or toast notification. The input here is the save completion status, and the output is the notification displayed to the user.

[1749] Steps for Providing Reflection Prompts

[1750] Step 1:

[1751] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[1752] Specific behavior: When a user selects the weekly reflection option from the menu, the device loads and displays the corresponding screen. The input is the user's operation, and the output is the display of the reflection screen.

[1753] Step 2:

[1754] The user taps the "Accept Prompt" button.

[1755] Specific behavior: When the user taps the "Accept Prompt" button, this becomes the input.

[1756] Step 3:

[1757] The terminal sends the request to the server.

[1758] Specific behavior: The request is sent to the server as an HTTP request. The input is the request from the user, and the output is the request sent.

[1759] Step 4:

[1760] Based on the received request, the server randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[1761] Specific behavior: The server randomly selects one from the prompt list and retrieves it. The input is the request and the prompt list, and the output is the selected message.

[1762] Step 5:

[1763] The server sends the selected reflection prompt to the terminal.

[1764] Specific operation: The server returns an HTTP response containing the selected message to the terminal. The input is the selected message, and the output is the HTTP response.

[1765] Step 6:

[1766] The terminal displays the received reflection prompt to the user.

[1767] Specific operation: The terminal displays the received message on the screen and presents it to the user. The input here is the HTTP response, and the output is the prompt message displayed to the user.

[1768] (Application example 2)

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

[1770] Mental health has become a major issue in modern society. It is particularly important for individuals to appropriately manage their emotions and reduce mental stress. However, in busy daily lives, it is difficult to regularly record and analyze emotions, and it is also difficult to respond immediately when excessive stress occurs. There is a need for a system that can solve these problems and efficiently support users' mental health.

[1771] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving emotion data input by the user, means for saving the received emotion data in a database, means for randomly selecting a message to periodically provide the user with a reflection prompt, and means for notifying an emergency contact when excessive mental stress is detected. This makes it possible to periodically record and analyze the user's emotions, provide feedback at an appropriate time, and respond quickly in an emergency.

[1772] "Emotion data" refers to information relating to emotions input by a user, and is digital information that indicates the user's emotional state.

[1773] A "database" is a system for systematically storing and managing received emotion data, and is an information resource for efficiently managing large amounts of data.

[1774] "Reflection prompts" are messages that encourage users to self-awareness and reflect on their emotions, and are leading questions that allow users to reevaluate their own emotions.

[1775] "Mental stress" refers to a state of psychological or emotional pressure or tension, and refers to the mental burden on the user.

[1776] An "emergency contact" is a contact to be notified when the user experiences excessive mental stress, and is a person to be contacted in an emergency.

[1777] The "Self-Mental Care Guard" system of the present invention aims to promote self-understanding and mental care by allowing users to record their own emotions and receive periodic reflection prompts. It also has a function to notify emergency contacts if excessive mental stress is detected. A specific embodiment of this system will be described below.

[1778] User emotion record

[1779] 1. Display the emotion input screen

[1780] The terminal starts the application and displays an interface (emotion input screen) for the user to input emotions.

[1781] The user enters their current emotion (e.g., "happy," "sad," etc.) in a text field.

[1782] 2. Sending Emotional Data

[1783] After inputting the emotion, the user taps the "Send" button, which sends the emotion data from the device to the server.

[1784] 3. Emotion Data Analysis

[1785] The server analyzes the emotion data received from the device using an emotion engine, which uses natural language processing technology and machine learning algorithms to recognize the user's emotions.

[1786] 4. Storing Emotional Data

[1787] The server records the analyzed emotion data in an emotion log for each user, for example, in the form {'time': '2023-10-05 14:23:45', 'emotion': 'happy'} in the database.

[1788] 5. Recording completion notification

[1789] The server notifies the terminal that the emotion data has been successfully saved, and the terminal displays a message to the user saying "Emotions recorded."

[1790] Providing Reflection Messages

[1791] 1. Displaying the reflection screen

[1792] The terminal displays a reflection screen to a user who selects "Weekly Reflection" from the application menu.

[1793] 2. Request a Reflection Prompt

[1794] The user taps the "Accept Prompt" button, and the request is sent from the device to the server.

[1795] 3. Select a reflection prompt

[1796] When the server receives a request, it randomly selects one message from the list of reflected messages, for example, "What was the happiest moment of this week?"

[1797] 4. Sending a Reflection Prompt

[1798] The server sends the selected reflection prompt to the terminal.

[1799] 5. Displaying the Reflection Prompt

[1800] The device displays the received reflection prompt to the user, for example, "What was the happiest moment this week?"

[1801] Emergency notification function

[1802] 1. Detecting mental stress

[1803] The server analyzes the emotional data and detects if the user's mental stress level is high.

[1804] 2. Notification to emergency contacts

[1805] If an emergency call is deemed necessary, the server sends a notification to the user's designated emergency contacts, including a summary of the user's current mental state.

[1806] Hardware and software used

[1807] Device: Smartphone

[1808] Server: Cloud server (e.g. AWS, Google Cloud)

[1809] Database: SQL database (e.g. MySQL, PostgreSQL)

[1810] Emotion engine: Natural language processing techniques and machine learning algorithms (e.g., Python's NLTK, TensorFlow)

[1811] Communication library: requests library

[1812] Specific examples

[1813] Examples of emotion recording

[1814] The user opens the application and enters their current emotion, "Sad." When they tap the "Send" button, the device sends the emotion data "Sad" and the current date and time to the server. The server analyzes the received data with its emotion engine and recognizes the emotion "Sad." It then adds this data to the user's emotion log and notifies them that it was successfully recorded. The device then displays "Emotion recorded."

[1815] Specific examples of reflection messages

[1816] At the end of the week, the user opens the application, selects the "Weekly Reflection" menu, and taps the "Receive Prompt" button. The device sends a request to the server, which selects the message "What was the happiest moment this week?" from the reflection message list. This message is sent to the device and displayed to the user.

[1817] Example of operation

[1818] Prompt Sentence Examples

[1819] "What was your happiest moment this week?"

[1820] By utilizing a generative AI model, we can realize effective self-mental care and support the user's mental health. This system allows users to efficiently practice self-mental care through recording their emotions and weekly reflection. It also enables rapid response in emergencies.

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

[1822] Step 1:

[1823] The device displays an interface (emotion input screen) for the user to input emotions. This interface includes a text field for inputting emotions and a "Send" button. The user enters the current emotion in the text field and taps the "Send" button.

[1824] Input: Emotion data entered by the user

[1825] Output: Emotion data is sent to the device.

[1826] Step 2:

[1827] When the user taps the "Send" button, the device sends the entered emotion data and the current date and time to the server. At this stage, the device packages the emotion data in JSON format or similar and sends it to the server using an HTTP request.

[1828] Input: Emotion data entered into the device and the current date and time

[1829] Output: Emotion data and date and time are sent to the server.

[1830] Step 3:

[1831] The server analyzes the emotion data received from the device. Specifically, an emotion engine running on the server analyzes the received data and recognizes the user's emotion. The emotion engine uses natural language processing technology and machine learning algorithms. Through this analysis, the emotion data is recognized as emotions such as "happy" or "sad."

[1832] Input: Emotion data and date and time sent to the server

[1833] Output: Parsed emotion data

[1834] Step 4:

[1835] The server stores the analyzed emotion data in a database. At this time, the emotion data is recorded as an emotion log for each user. For example, the data is stored in the format {'time': '2023-10-05 14:23:45', 'emotion': 'Happy'}.

[1836] Input: Parsed emotion data

[1837] Output: Emotion data is saved in the database

[1838] Step 5:

[1839] The server notifies the device that the emotion data has been successfully saved. The device then displays a message to the user saying, "Emotions have been recorded." This message lets the user know that their emotion has been recorded.

[1840] Input: Save completion notification from the server

[1841] Output: Display the message "Emotions recorded" on the terminal.

[1842] Step 6:

[1843] The user selects the "Weekly Reflection" menu and taps the "Receive Prompt" button. The device sends a reflection prompt request to the server. The request includes the user ID and reflection prompt request metadata.

[1844] Input: Reflection prompt request from user

[1845] Output: The request is sent to the server

[1846] Step 7:

[1847] When the server receives the request, it randomly selects a prompt from the list of reflection messages. For example, the message "What was the happiest moment of this week?" is selected and sent from the server to the device.

[1848] Input: Reflection prompt request from user

[1849] Output: A randomly chosen reflection message is sent to the terminal.

[1850] Step 8:

[1851] The device displays the reflection prompt received from the server to the user, allowing the user to reflect on their self-awareness and emotions.

[1852] Input: Reflected prompt sent from the server

[1853] Output: A reflection prompt appears in the terminal

[1854] Step 9:

[1855] The server analyzes the emotional data and detects if the user's mental stress level is high. Specifically, it analyzes past emotional logs and detects excessive stress if a certain threshold is exceeded.

[1856] Input: Emotion data stored on the server

[1857] Output: Mental stress level evaluation results

[1858] Step 10:

[1859] If excessive mental stress is detected, the server sends a notification to the user's designated emergency contacts, along with a summary of the user's current mental state.

[1860] Input: Mental stress level assessment results

[1861] Output: Notification sent to emergency contacts

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

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

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

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

[1866] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[1883] The following is further disclosed regarding the above embodiment.

[1884] (Claim 1)

[1885] means for receiving emotion data input by a user;

[1886] a means for storing the received emotion data in a database;

[1887] means for randomly selecting a message to periodically provide a reflection prompt to the user;

[1888] means for displaying the provided message to the user;

[1889] A system including:

[1890] (Claim 2)

[1891] 10. The system of claim 1, wherein the reflection prompts relate to positive experiences in the user's life.

[1892] (Claim 3)

[1893] 2. The system of claim 1, wherein the emotion data includes a type of emotion and a date and time when the emotion was recorded.

[1894] "Example 1"

[1895] (Claim 1)

[1896] means for receiving emotion data input by a user;

[1897] a means for storing the received emotion data in a database;

[1898] means for randomly selecting a message to periodically provide a reflection prompt to the user;

[1899] means for displaying the provided message to the user;

[1900] a means for notifying completion of transmission of emotion data;

[1901] A system including:

[1902] (Claim 2)

[1903] 10. The system of claim 1, wherein the reflection prompts relate to positive experiences in the user's life.

[1904] (Claim 3)

[1905] 2. The system of claim 1, wherein the emotion data includes a type of emotion and a date and time when the emotion was recorded.

[1906] "Application Example 1"

[1907] (Claim 1)

[1908] means for receiving emotion data input by a user;

[1909] a means for storing the received emotion data in a database;

[1910] means for randomly selecting a message to periodically provide a reflection prompt to the user;

[1911] means for displaying the provided message to the user;

[1912] A means for employees to record their daily work emotions and provide weekly reflection messages to promote self-understanding.

[1913] A system including:

[1914] (Claim 2)

[1915] 10. The system of claim 1, wherein the reflection prompts relate to positive experiences in the user's life.

[1916] (Claim 3)

[1917] 2. The system of claim 1, wherein the emotion data includes a type of emotion and a date and time when the emotion was recorded.

[1918] "Example 2: Combining Emotion Engines"

[1919] (Claim 1)

[1920] means for receiving emotion data input by a user;

[1921] means including a natural language processing engine for analyzing the received emotion data;

[1922] A means for storing the analyzed emotion data in a database;

[1923] means for randomly selecting a message to periodically provide a reflection prompt to the user;

[1924] means for displaying the selected reflection prompt to the user;

[1925] A system including:

[1926] (Claim 2)

[1927] 10. The system of claim 1, wherein the reflection prompts relate to positive experiences in the user's life.

[1928] (Claim 3)

[1929] 2. The system of claim 1, wherein the emotion data includes a type of emotion and a date and time when the emotion was recorded.

[1930] "Application example 2 when combining emotion engines"

[1931] (Claim 1)

[1932] means for receiving emotion data input by a user;

[1933] a means for storing the received emotion data in a database;

[1934] means for randomly selecting a message to periodically provide a reflection prompt to the user;

[1935] means for displaying the provided message to the user;

[1936] A means of notifying emergency contacts if excessive mental stress is detected;

[1937] A system including:

[1938] (Claim 2)

[1939] 10. The system of claim 1, wherein the reflection prompts relate to positive experiences in the user's life.

[1940] (Claim 3)

[1941] 2. The system of claim 1, wherein the emotion data includes a type of emotion and a date and time when the emotion was recorded. [Explanation of symbols]

[1942] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. means for receiving emotion data input by a user; a means for storing the received emotion data in a database; means for randomly selecting a message to periodically provide a reflection prompt to the user; means for displaying the provided message to the user; A system including:

2. The system of claim 1 , wherein the reflection prompts relate to positive experiences in the user's life.

3. The system of claim 1 , wherein the emotion data includes a type of emotion and a date and time when the emotion was recorded.

Images