System

Abstract

A system is provided.SOLUTION: The system includes a means for collecting past customer service data, a means for using a generation type artificial intelligence for learning the collected customer service data, a means for automatically generating a complaint handling manual based on a learning result, a means for storing the generated complaint handling manual, and a means for retrieving and displaying the generated complaint handling manual via a user interface.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] In modern customer service, handling complaints is an important task, but traditional methods require a great deal of time and effort to create and update manuals. This makes it difficult to train and develop new employees to handle complaints quickly and accurately, which can lead to lower customer satisfaction and a loss of corporate credibility. Furthermore, the quality of complaint handling tends to depend on the experience and knowledge of each individual, resulting in a lack of consistency. There is a need to solve these problems. [Means for solving the problem]

[0005] This invention provides a system that automatically generates a complaint handling manual by collecting past customer service data and using generative artificial intelligence to learn from it. The system formats and cleanses the collected data, extracts specific keywords and patterns based on the learning results, and generates a complaint handling manual. The generated manual is then saved and can be searched and displayed via a user interface. As a result, new employees can handle complaints quickly and accurately, contributing to improved customer satisfaction and maintaining the company's credibility. Furthermore, manual updates are automated, ensuring that responses are always based on the latest information.

[0006] "Customer service data" refers to information including inquiries, complaints, and feedback from customers, as well as responses thereto.

[0007] "Generative AI" is AI that has the ability to generate new data and information using algorithms such as machine learning and deep learning.

[0008] A "complaint handling manual" is a document that summarizes procedures and necessary information for responding to customer complaints and inquiries.

[0009] "Means of collection" refers to the methods or techniques used to obtain and gather specific information from databases, files, etc.

[0010] A "learning tool" is a method or technique for using generative artificial intelligence to extract patterns and knowledge from collected data.

[0011] "Automatic generation means" means a method or technology that uses artificial intelligence to create documents or information without manual intervention.

[0012] "Storage means" refers to the method or technology used to store and maintain generated data and documents in a database or storage.

[0013] A "user interface" is something that provides a screen and operation method for a user to interact with a system.

[0014] A "search tool" is a method or technique for quickly finding specific information or data.

[0015] "Display means" refers to a method or technique for visualizing the retrieved information or data on the user's screen.

[0016] "Forming and cleansing measures" are methods or techniques for arranging collected data into a certain format and removing missing values ​​and irrelevant items.

[0017] "Keywords and patterns" are important words and patterns that appear frequently in the data. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0026] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0039] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). This system includes a data collection module, a data processing module, a manual generation module, and a user interface (UI) module.

[0040] Data Collection Module

[0041] Data collection

[0042] The server collects historical customer service data from the company's database, including customer inquiries, complaints, feedback, and responses thereto.

[0043] For example, the server executes an SQL query to extract data in the form "SELECT FROM cs_responses WHERE date > '2022-01-01'".

[0044] Uploading additional data

[0045] A user (administrator) uploads new data to the system. This additional data is typically provided in a CSV file format.

[0046] For example, a user adds new data to the system using the command "upload_file('new_cs_responses.csv')".

[0047] Data Processing Module

[0048] Data Cleansing

[0049] The server cleanses the collected or uploaded data, which includes removing missing values ​​and formatting the data.

[0050] For example, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[0051] Data training

[0052] The server then feeds the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process is done using machine learning libraries (e.g., TENSORFLOW®, PyTorch).

[0053] For example, a learning model is constructed using the following commands: "model.fit(data)" and "model.save('cs_model.h5')".

[0054] Manual Generation Module

[0055] Keyword and pattern extraction

[0056] The server uses a trained AI model to extract keywords and patterns relevant to a specific scenario.

[0057] For example, use an AI model to extract frequently occurring keywords using the format "keywords = model.extract_keywords(data)".

[0058] Manual creation

[0059] The server uses a generative AI model to automatically generate a complaint handling manual based on the extracted information. The generated manual includes specific response procedures and important points to note.

[0060] For example, a manual can be generated using the operation "manual_text = gpt.generate_manual(keywords)".

[0061] Saving the manual

[0062] The server stores the generated manual in a database or storage, which serves as the basis for later retrieval and display.

[0063] For example, saving is done in the form "save_manual_db('manual_2023_01', manual_text)".

[0064] User Interface Module

[0065] Search for manuals

[0066] When a user (new employee) wants to know how to handle a specific complaint, he or she enters search keywords through the UI.

[0067] For example, a user searches the system using the following format: "search_manual('The product arrived damaged')".

[0068] View the manual

[0069] The terminal sends a request to the server to retrieve and display the relevant manual.

[0070] For example, the server searches for related manual entries and returns the results to the terminal as "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'". The results are displayed on the terminal as "display_manual(result)".

[0071] As a concrete example, when a new employee responds to a complaint that "the product arrived damaged," the user first searches for the problem in the UI. The server retrieves the relevant manual from the database and displays it on the terminal. The new employee can then refer to the displayed manual and handle the complaint by following specific procedures, such as taking a photo, completing the return procedure, and arranging for a replacement. In this way, complaints are handled quickly and in a unified manner, leading to improved customer satisfaction.

[0072] The processing flow will be explained below.

[0073] Step 1:

[0074] The server collects historical customer service data from the company's database by issuing an SQL query to the database, such as "SELECT FROM cs_responses WHERE date > '2022-01-01'".

[0075] Step 2:

[0076] A user (administrator) uploads new complaint response data to the system. The uploaded data is provided in a CSV file format, and the user adds the file to the system using the command "upload_file('new_cs_responses.csv')".

[0077] Step 3:

[0078] The server cleanses the uploaded data. This includes removing missing values ​​and formatting the data. For example, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[0079] Step 4:

[0080] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process is done using machine learning libraries (e.g., TensorFlow, PyTorch). For example, the learning model is built using "model.fit(data)" or "model.save('cs_model.h5')".

[0081] Step 5:

[0082] The server uses the trained AI model to extract keywords and patterns relevant to a specific scenario from historical customer service data. For example, the AI ​​model can be used to extract frequently occurring keywords using the formula "keywords = model.extract_keywords(data)".

[0083] Step 6:

[0084] The server automatically generates a complaint handling manual using a generative AI model based on the extracted keywords and patterns. The generated manual includes specific response procedures and important points to note. For example, a manual can be generated using the operation "manual_text = gpt.generate_manual(keywords)".

[0085] Step 7:

[0086] The server saves the generated manual in a database or storage. This saved manual serves as the basis for later searching and display. For example, it is saved in the form of "save_manual_db('manual_2023_01', manual_text)".

[0087] Step 8:

[0088] A user (new employee) searches for a specific complaint handling method through the user interface. For example, the user searches the system using the form "search_manual('The product arrived damaged')".

[0089] Step 9:

[0090] The terminal sends a request to the server to retrieve and display the relevant manual. The server executes the SQL query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" to search for the relevant manual and returns the results to the terminal. The result is displayed on the terminal as "display_manual(result)".

[0091] Step 10:

[0092] The user (new employee) refers to the displayed manual and follows specific complaint handling procedures. For example, in the case of a damaged product, the user can practice procedures such as "have a photo taken," "proceed with the return shipping," and "arrange for a replacement."

[0093] Example 1

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

[0095] Conventional complaint handling systems have had problems with insufficient use of past customer service data, resulting in a lack of quality and speed in responses. Furthermore, the creation of response manuals is often manual, resulting in inefficiency and a lack of consistency. The present invention aims to solve these problems by providing a system that automatically generates prompt and appropriate complaint handling manuals while effectively utilizing past data.

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

[0097] In this invention, the server includes means for collecting past customer service data, means for uploading the collected customer service data, means for cleansing the uploaded data, means for learning the cleansed data using generative artificial intelligence, means for extracting keywords and patterns related to a specific scenario based on the learning results, means for automatically generating a complaint handling manual based on the extracted information, means for saving the generated complaint handling manual, and means for searching for and displaying the generated complaint handling manual via a user interface. This enables the effective use of past data to automatically generate a complaint handling manual that is quick and consistent.

[0098] "Past customer service data" refers to data that includes information about customer service, such as inquiries, complaints, feedback, and responses thereto from past customers.

[0099] "Means of collection" refers to the processes and tools used to obtain historical customer service data from a company's database.

[0100] "Means of uploading" refers to the operations or interface that a user (administrator) uses to add new data to the system.

[0101] "Cleansing measures" refers to processes used to remove missing values ​​or format collected or uploaded data.

[0102] "Generative AI" refers to an AI technology that can learn patterns and important keywords from input data and generate new information based on that.

[0103] "Means of learning" refers to the process by which generative AI uses cleansed data to learn patterns and important keywords from the data.

[0104] "Means for extracting keywords and patterns relevant to a specific scenario" refers to the process of using the learning results to extract important keywords and patterns necessary to respond to a specific situation.

[0105] A "complaint handling manual" refers to a guideline that lists procedures and precautions for handling customer complaints.

[0106] "Means for automatic generation" refers to the process of automatically creating a complaint handling manual based on the extracted information using generative artificial intelligence.

[0107] "Means for storage" refers to the processes and tools for storing the generated complaint handling manual in a database or other storage.

[0108] "User interface" refers to the screen and input means through which a user interacts with a system.

[0109] "Means for searching and displaying" refers to the process or tool that allows a user to find a specific complaint handling manual and display it on a terminal.

[0110] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). The system includes a data collection module, a data processing module, a manual generation module, and a user interface (UI) module.

[0111] Data Collection Module

[0112] The server connects to the company's database to collect historical customer service data. This data can be collected using SQL queries. For example, the query "SELECT FROM cs_responses WHERE date > '2022-01-01'" is executed to retrieve the data. The collected data is stored in the system's memory.

[0113] Uploading additional data

[0114] When a user (administrator) uploads new data to the system, they use a file, such as a CSV file. The upload operation is performed using the system's UI, and data is added using a command such as "upload_file('new_cs_responses.csv')". Once the upload is complete, the system validates the new data and merges it with the existing data.

[0115] Data Processing Module

[0116] The server cleanses the collected or uploaded data. This process includes removing missing values ​​and formatting the data. Specifically, it reads the data with "data = pd.read_csv('new_cs_responses.csv')" and removes missing data with "data.dropna(inplace=True)". The cleansed data is saved for the next learning step.

[0117] Data training

[0118] The server inputs the cleansed data into a generative AI model to learn patterns and important keywords. This uses machine learning libraries (e.g., TensorFlow, PyTorch). For example, run "model.fit(data)" to train the model, and then run "model.save('cs_model.h5')" to save the trained model. This process enables the AI ​​model to extract useful patterns and keywords from past claim data.

[0119] Manual Generation Module

[0120] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. For example, it runs the code "keywords = model.extract_keywords(data)" to extract frequently occurring keywords. Next, a complaint handling manual is automatically generated by the generative AI model based on the extracted keywords. Specifically, the manual is generated using the operation "manual_text = gpt.generate_manual(keywords)". This manual includes specific procedures and reference information for handling complaints.

[0121] Saving the manual

[0122] The server saves the generated manual in a database or storage. For example, it executes the code "save_manual_db('manual_2023_01', manual_text)" to save the manual. The saved manual is structured so that it can be easily searched and displayed later.

[0123] User Interface Module

[0124] When a user (new employee) wants to know how to handle a specific complaint, they enter search keywords through the UI. For example, they enter the search query "search_manual('The product arrived damaged')". The server receives this request and searches the database for relevant manuals.

[0125] The terminal sends a request to the server to retrieve and display the related manual. For example, the server executes the query "SELECT FROM manuals WHERE keywords LIKE '%product is damaged%'" and sends the result to the terminal. The terminal executes the code "display_manual(result)" to display the contents of the related manual to the user.

[0126] An example prompt might be, "What is the procedure for handling a damaged product?" This process allows users to quickly find how to handle a specific complaint and follow the procedure.

[0127] As a concrete example, when a new employee responds to a complaint that "the product arrived damaged," the user first inputs the problem details into the UI, searches for it, and then follows the procedure based on the manual that is displayed. This allows complaints to be handled quickly and in a consistent manner, which is expected to improve customer satisfaction.

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

[0129] Step 1:

[0130] Data collection

[0131] The server connects to the company's database and retrieves historical customer service data.

[0132] Input: Your company's database connection information and query (e.g., "SELECT FROM cs_responses WHERE date > '2022-01-01'").

[0133] Output: The retrieved customer service data.

[0134] How it works: The server executes an SQL query to extract data from the database for a specified period of time, which is then loaded into memory for further processing.

[0135] Step 2:

[0136] Uploading additional data

[0137] The user (administrator) uploads new data to the system.

[0138] Input: New data file (e.g. "new_cs_responses.csv" in CSV format).

[0139] Output: The new data uploaded.

[0140] How it works: A user adds new data to the system by executing the command "upload_file('new_cs_responses.csv')" through the system's UI. Once the file is uploaded, the system validates the new data and integrates it into the existing dataset.

[0141] Step 3:

[0142] Data Cleansing

[0143] The server cleanses the collected or uploaded data.

[0144] Input: Data collected or uploaded.

[0145] Output: The cleansed data.

[0146] Operation: The server executes the code "data = pd.read_csv('new_cs_responses.csv')" to read the data, executes "data.dropna(inplace=True)" to remove missing data, formats the data, and proceeds to the next step.

[0147] Step 4:

[0148] Data training

[0149] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data.

[0150] Input: Cleansed data.

[0151] Output: A trained AI model.

[0152] How it works: The server uses a machine learning library (e.g., TensorFlow, PyTorch) to run "model.fit(data)" to train the data. Once training is complete, it saves the model with "model.save('cs_model.h5')". This allows the AI ​​model to learn useful patterns and keywords from past claim data.

[0153] Step 5:

[0154] Keyword and pattern extraction

[0155] The server uses a trained AI model to extract keywords and patterns relevant to a specific scenario.

[0156] Input: Cleansed data and a trained AI model.

[0157] Output: Extracted keywords and patterns.

[0158] How it works: The server runs the code "keywords = model.extract_keywords(data)" to extract important keywords and patterns from the data that are relevant to the specific scenario. These results are used in the next manual generation step.

[0159] Step 6:

[0160] Manual creation

[0161] Based on the extracted keywords and patterns, the server automatically generates a complaint handling manual using a generative AI model.

[0162] Input: Extracted keywords and patterns.

[0163] Output: Automatically generated complaint handling manual.

[0164] Operation: The server executes the code "manual_text = gpt.generate_manual(keywords)" to generate a complaint handling manual. The generated manual includes specific response procedures and important points to note.

[0165] Step 7:

[0166] Saving the manual

[0167] The server stores the generated complaint handling manual in a database or storage.

[0168] Input: Generated complaint handling manual.

[0169] Output: Manuals stored in a database or storage.

[0170] What happens: The server runs the code "save_manual_db('manual_2023_01', manual_text)" to save the manual to the database, laying the groundwork for later retrieval and display.

[0171] Step 8:

[0172] Search for manuals

[0173] When a user (new employee) wants to know how to handle a specific complaint, he or she enters search keywords through the UI.

[0174] Input: Search keywords (e.g. "The product arrived damaged").

[0175] Output: Related complaint handling manual.

[0176] How it works: A user enters a search query via the UI: "search_manual('The product arrived damaged')". The server receives the request and searches the database for the corresponding manual.

[0177] Step 9:

[0178] View the manual

[0179] The terminal sends a request to the server to retrieve and display the relevant manual.

[0180] Input: Search results received from the server.

[0181] Output: Complaint handling manual displayed on the terminal.

[0182] Operation: The server executes the query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" to retrieve the relevant manual. The terminal executes the code "display_manual(result)" to display the contents of the relevant manual to the user.

[0183] (Application example 1)

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

[0185] While automated production lines in modern factories have significantly improved efficiency, they can also have a negative impact on productivity if unexpected errors or complaints are not dealt with promptly. Furthermore, it is difficult for new staff to deal with these issues quickly and accurately, leading to the risk of delayed responses or inappropriate handling. This invention aims to respond quickly and effectively to errors and complaints that occur on production lines, reducing the burden on staff while maintaining production efficiency.

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

[0187] In this invention, the server includes means for collecting past customer service data, means for using generative artificial intelligence to learn the collected customer service data, means for automatically generating a complaint handling manual based on the learning results, means for saving the generated complaint handling manual, means for searching and displaying the generated complaint handling manual via a user interface, and means for generating a manual for resolving errors and complaints that occur in the automation system in the factory. This enables a quick and unified response to errors and complaints that occur in the factory.

[0188] "Historical customer service data" refers to data that a company collects and stores, such as information about customer service inquiries, complaints, feedback, and responses to such inquiries and complaints.

[0189] "Means of collection" refers to the process or mechanism by which the required customer service data is obtained from a company's database.

[0190] "Generative artificial intelligence" refers to AI systems that have the ability to analyze collected data, learn, and generate new information and answers.

[0191] A "complaint handling manual" is a document that lists specific procedures and points to note when dealing with complaints and inquiries from customers.

[0192] "Means for storage" refers to a system for properly storing the generated complaint handling manual in a database or storage for a certain period of time.

[0193] "User interface" refers to the software and hardware configuration that allows a user to interact with a system, and specifically includes a screen, input device, and the like.

[0194] "Means for searching and displaying" refers to a function for searching the complaint handling manual stored in the database as needed and visually displaying the results to the user.

[0195] "Factory automation system" refers to an integrated system of hardware and software for automatically executing manufacturing processes.

[0196] "Means for generating manuals for resolving errors and complaints" refers to a mechanism for automatically creating resolution procedures based on past data for problems that occur in automated systems within a factory.

[0197] As an embodiment of the present invention, a specific system implementation for dealing with errors and complaints in an automation system within a factory will be described below.

[0198] The system includes a data collection module for collecting past customer service data, a data processing module for cleansing and formatting the collected data, a manual generation module for automatically generating complaint handling manuals using generative artificial intelligence, a UI module for searching and displaying saved manuals via a user interface, and a means for quickly responding to errors and complaints that occur in the automation systems within the factory.

[0199] The server first collects past customer service data from the company's database. Specifically, it executes SQL queries to extract the necessary data from the database. The range and format of data to be collected are set by default. The server also provides a means for users to upload new data, ensuring that the system is always running with the latest data.

[0200] The collected data is then cleansed and formatted by a data processing module, which uses Python and Pandas to remove missing values ​​and standardize the data format, allowing the generative artificial intelligence to learn efficiently.

[0201] After the data is prepared, the server uses generative artificial intelligence (for example, GPT-3 (registered trademark) or TensorFlow) to automatically generate a complaint handling manual from the data. The generative artificial intelligence learns from the data and generates a new manual based on past error resolution methods and complaint handling procedures.

[0202] The generated complaint handling manual is stored in server storage, which provides the foundation for later retrieval and display. A user interface (e.g., a web interface using Flask) is provided, through which users can search for response procedures based on specific errors or complaints.

[0203] As an actual usage example, consider the case where a robot in a factory stops working. In this case, the user enters a complaint, such as "The robot arm has stopped," into the interface and searches. The server searches the database for the relevant complaint handling manual and displays the generated procedure on the user's device. This allows the user to solve the problem quickly and accurately.

[0204] An example of an actual prompt is as follows:

[0205] text

[0206] Generate a complaint handling manual: The robot arm has stopped

[0207] In this way, the present invention is a system that enables a quick and unified response to errors and complaints that occur in the automation system within a factory, maintaining production efficiency while reducing the burden on staff.

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

[0209] Step 1: Data collection

[0210] The server collects historical customer service data from the company's database. It uses SQL queries to select data that matches certain criteria. For example, it executes a query like "SELECT FROM cs_responses WHERE date > '2022-01-01'." The input is the customer service data stored in the database, and the output is a list of data that matches the query. Users can also upload new data; in this case, the additional data is uploaded to the server in CSV format. The server then merges this new data with the existing data.

[0211] Step 2: Cleanse and shape the data

[0212] The server cleanses and formats the collected data using Python and the Pandas library. This involves removing missing values ​​and standardizing the data format. For example, "data.dropna(inplace=True)" is used to remove missing values, and then the data is formatted. The input to this step is the collected customer service data, and the output is the cleansed and formatted data.

[0213] Step 3: Train the data

[0214] The server inputs the cleansed data into a generative AI model for learning. The generative AI model used is TensorFlow, which learns patterns and important keywords from the data. Specifically, learning proceeds using "model.fit(data)", and then the model is saved using "model.save('cs_model.h5')". The input is the cleansed and formatted data, and the output is the trained AI model.

[0215] Step 4: Extracting keywords and patterns

[0216] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. Specifically, it extracts frequently occurring keywords using the formula "keywords = model.extract_keywords(data)". The input for this step is the trained AI model and newly provided scenario data, and the output is specific keywords and patterns.

[0217] Step 5: Automatic generation of manuals

[0218] The server automatically generates a complaint handling manual using a generative AI model based on the extracted keywords and patterns. In this case, it is common to use GPT-3 as the generative AI model. Specifically, the manual is generated using "manual_text = gpt.generate_manual(keywords)". The input is specific keywords and patterns, and the output is the generated complaint handling manual.

[0219] Step 6: Save the manual

[0220] The server saves the generated complaint handling manual in a database or storage. For example, it is saved as "save_manual_db('manual_2023_01', manual_text)". The input of this step is the generated manual, and the output is the manual saved in the database.

[0221] Step 7: Search and view the documentation

[0222] When a user wants to know how to handle a particular complaint, they enter relevant keywords through the user interface. The server searches the database for relevant manuals based on those keywords and displays them on the user's terminal. For example, if a user searches for "search_manual('The robot arm has stopped')", the server searches as "SELECT FROM manuals WHERE keywords LIKE '%robot arm%'" and returns the results to the user's terminal, which displays them as "display_manual(result)". The input to this step is the keyword entered by the user, and the output is the relevant manual displayed on the user's terminal.

[0223] Through these steps, this system enables a quick and unified response to errors and complaints that occur in the automation systems within a factory.

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

[0225] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). Furthermore, this system incorporates an emotion engine that recognizes user emotions, enabling the quality of complaint handling to be improved based on emotions. This system includes a data collection module, a data processing module, a manual generation module, an emotion engine module, and a user interface (UI) module.

[0226] Data Collection Module

[0227] Data collection

[0228] The server collects historical customer service data from the company's database by issuing an SQL query to the database, such as "SELECT FROM cs_responses WHERE date > '2022-01-01'".

[0229] Uploading additional data

[0230] A user (administrator) uploads new complaint response data to the system. The uploaded data is provided in a CSV file format, and the user adds the file to the system using the command "upload_file('new_cs_responses.csv')".

[0231] Data Processing Module

[0232] Data Cleansing

[0233] The server cleanses the collected or uploaded data. This includes removing missing values ​​and formatting the data. For example, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[0234] Data training

[0235] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process is done using machine learning libraries (e.g., TensorFlow, PyTorch). For example, the learning model is built using "model.fit(data)" or "model.save('cs_model.h5')".

[0236] Emotion Engine Module

[0237] Emotion recognition

[0238] The server uses an emotion engine to extract emotions from the user's input voice or text. The emotion engine uses natural language processing and speech analysis technologies to recognize emotional states such as anger, sadness, and joy.

[0239] For example, for voice input, emotions are analyzed using "audio_emotion = emotion_engine.analyze_audio(user_input)", and for text input, emotions are analyzed using "text_emotion = emotion_engine.analyze_text(user_input)".

[0240] Manual Generation Module

[0241] Keyword and pattern extraction

[0242] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. For example, the AI ​​model can be used to extract frequently occurring keywords using the format "keywords = model.extract_keywords(data)".

[0243] Manual creation

[0244] The server uses a generative AI model to automatically generate a complaint handling manual based on the extracted information. The generated manual includes specific response procedures and important points to note. The content and tone of the manual are also adjusted based on the recognized emotions.

[0245] For example, if the user is feeling angry, a particularly polite and careful response procedure can be incorporated. The manual is generated using the operation "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)".

[0246] Saving the manual

[0247] The server saves the generated manual in a database or storage. This saved manual serves as the basis for later searching and display. For example, it is saved in the form of "save_manual_db('manual_2023_01', manual_text)".

[0248] User Interface Module

[0249] Search for manuals

[0250] A user (new employee) searches for a specific complaint handling method through the user interface. For example, the user searches the system using the form "search_manual('The product arrived damaged')".

[0251] View the manual

[0252] The terminal sends a request to the server to retrieve and display the relevant manual. The server executes the SQL query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" to search for the relevant manual and returns the results to the terminal. The result is displayed on the terminal as "display_manual(result)".

[0253] Specific examples

[0254] For example, when a new employee responds to a complaint that "the product arrived damaged," the process would be as follows:

[0255] 1. A user (new employee) accepts a complaint and searches for the problem using the user interface.

[0256] 2. The server extracts appropriate keywords based on past data and generates a corresponding manual based on them.

[0257] 3. The emotion engine recognizes the user's (customer's) emotions and reflects them in the manual. For example, if a customer is angry, a particularly polite and prompt response procedure is required.

[0258] 4. The terminal displays the generated manual, and the user refers to it and takes appropriate action.

[0259] In this way, complaints can be dealt with promptly and appropriately, leading to improved customer satisfaction.

[0260] The processing flow will be explained below.

[0261] Step 1:

[0262] The server collects past customer service data from the company's database. Specifically, the server issues the SQL query "SELECT FROM cs_responses WHERE date > '2022-01-01'" to extract the target data from the database.

[0263] Step 2:

[0264] The user (administrator) uploads new complaint response data to the system. To upload, use the command "upload_file('new_cs_responses.csv')" to add data in CSV file format.

[0265] Step 3:

[0266] The server cleanses the uploaded data. It uses Python or similar tools to remove missing values ​​and format the data. For example, it uses operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[0267] Step 4:

[0268] The server inputs the cleansed data into a generative AI model, and uses machine learning libraries (e.g., TensorFlow, PyTorch) to learn patterns and important keywords from the data. Specifically, the learning model is constructed using commands such as "model.fit(data)" and "model.save('cs_model.h5')."

[0269] Step 5:

[0270] The server uses the emotion engine to extract emotions from the user's input voice or text. The emotion engine recognizes the user's emotional state using natural language processing and voice analysis technology. Specifically, for voice input, it performs the operation "audio_emotion = emotion_engine.analyze_audio(user_input)", and for text input, it performs the operation "text_emotion = emotion_engine.analyze_text(user_input)".

[0271] Step 6:

[0272] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. For example, it obtains frequently occurring keywords using the format "keywords = model.extract_keywords(data)".

[0273] Step 7:

[0274] The server uses a generative AI model to automatically generate a complaint handling manual based on the extracted keywords and the emotions recognized by the emotion engine. For example, if the user is feeling angry, a manual is created that includes polite and careful response procedures. The manual is generated using the operation "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)".

[0275] Step 8:

[0276] The server saves the generated manual to a database or storage. This is done in the form of "save_manual_db('manual_2023_01', manual_text)".

[0277] Step 9:

[0278] A user (new employee) searches for a specific complaint handling method through the user interface. For example, they search the system using the form "search_manual('The product arrived damaged')".

[0279] Step 10:

[0280] The terminal sends a request to the server to retrieve and display the relevant manual. The server executes the SQL query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" and returns the results to the terminal. The terminal displays the manual in the form of "display_manual(result)".

[0281] Step 11:

[0282] The user (new employee) refers to the displayed manual and follows specific procedures for handling complaints. For example, in response to a complaint that a product was delivered damaged, the user takes a photo, goes through the return procedure, and arranges for a replacement.

[0283] Example 2

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

[0285] In conventional complaint handling systems, it was difficult to efficiently utilize past customer service data and quickly and appropriately generate customer handling manuals. Furthermore, because handling procedures were determined without taking into account the customer's feelings, it was difficult to improve customer satisfaction. The present invention aims to solve these problems and provide a new system for improving the quality of customer handling.

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

[0287] In this invention, the server includes means for collecting past customer service data, means for shaping and cleansing the collected customer service data, means for learning data using generative artificial intelligence, means for automatically generating a complaint handling manual based on the learning results, means for saving the generated complaint handling manual, means for searching and displaying the generated complaint handling manual via a user interface, and means for recognizing user emotions and adjusting the content of the complaint handling manual based on the recognition results. This makes it possible to efficiently utilize past data and quickly respond appropriately to customer emotions.

[0288] "Past customer service data" refers to historical information such as inquiries, complaints, and response history received by a company from customers.

[0289] "Formatting and cleansing" refers to preprocessing work to improve data quality, such as removing missing values ​​and standardizing the format of data.

[0290] "Generative AI" refers to AI technology that can extract patterns and keywords from data and generate new sentences and content.

[0291] A "complaint handling manual" refers to a guideline or procedure manual that shows the steps that should be taken to respond to customer complaints.

[0292] "Storage" refers to the process of storing the generated complaint handling manual in a database or storage so that it can be reused later.

[0293] The term "user interface" refers to the parts that are directly operated by the user, such as the screen and input method that allow the user to interact with the system.

[0294] "Search and display" refers to the process of locating and finding specific information from a database and presenting the results in a visible form to the user.

[0295] "Emotion recognition" refers to the technology of analyzing and identifying a user's emotional state from their input voice or text.

[0296] "Adjusting the content" refers to the process of changing the content and tone of the complaint handling manual in response to perceived emotions to ensure an appropriate response.

[0297] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). The system includes a data collection module, a data processing module, a manual generation module, an emotion engine module, and a user interface (UI) module.

[0298] Data Collection Module

[0299] The server issues an SQL query to the company's database to collect past customer service data. Specifically, the query format is "SELECT FROM cs_responses WHERE date > '2022-01-01'". Furthermore, the user (administrator) uploads new complaint response data to the system in CSV file format. Specifically, the upload method uses the command "upload_file('new_cs_responses.csv')".

[0300] Data Processing Module

[0301] The server cleanses the collected or uploaded data. Data cleansing includes removing missing values ​​and formatting the data. Specific examples of operations include "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)." The server then inputs the cleansed data into a generative AI model to learn patterns and important keywords from the data. This process uses a machine learning library (e.g., TensorFlow, PyTorch) and executes operations such as "model.fit(data)" and "model.save('cs_model.h5')."

[0302] Emotion Engine Module

[0303] The server uses an emotion engine to extract emotions from the user's input voice or text. The emotion engine uses natural language processing technology and voice analysis technology. Specific examples of operations include "audio_emotion = emotion_engine.analyze_audio(user_input)" for voice input and "text_emotion = emotion_engine.analyze_text(user_input)" for text input.

[0304] Manual Generation Module

[0305] The server uses a trained AI model to extract keywords and patterns related to a specific scenario. An example is "keywords = model.extract_keywords(data)". The server then uses a generative AI model based on the extracted information to automatically generate a complaint handling manual. The generated manual includes specific response procedures and points to note, and the content and tone are adjusted based on the recognized emotions. For example, a manual is generated using the operation "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)". The server then saves the generated manual in a database or storage. An example is "save_manual_db('manual_2023_01', manual_text)".

[0306] User Interface Module

[0307] A user (new employee) searches for a specific complaint handling method via the user interface. An example of a specific prompt sentence is "search_manual('The product arrived damaged')". The terminal then sends a request to the server to retrieve and display the relevant manual. The server executes the query "SELECT FROM manuals WHERE keywords LIKE '%The product arrived damaged%'" and returns the results to the terminal. The results are displayed on the terminal in the form of "display_manual(result)".

[0308] Specific examples

[0309] For example, if a new employee is responding to a complaint that "the product arrived damaged," the user (new employee) accepts the complaint and uses the user interface to search for the problem. They enter the prompt "search_manual('The product arrived damaged')." The server extracts appropriate keywords from past data and generates a response manual based on those keywords. Furthermore, an emotion engine recognizes the user's (customer's) emotions and reflects them in the manual content. For example, if the customer is angry, a particularly polite and prompt response procedure is required. The terminal displays the generated manual, and the user refers to it to respond. This process enables a quick and accurate response to the complaint, leading to improved customer satisfaction.

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

[0311] Step 1:

[0312] The server issues an SQL query to the company's database to collect historical customer service data. Specifically, it executes the query "SELECT FROM cs_responses WHERE date > '2022-01-01'". This operation pulls historical customer service data into the server. The input is the database query result, and the output is the collected customer service data.

[0313] Step 2:

[0314] The user (administrator) uploads new complaint response data to the system in CSV file format. The specific upload method is to use the command "upload_file('new_cs_responses.csv')". This operation adds the new complaint response data to the system. The input is the CSV file, and the output is the new data saved in the system.

[0315] Step 3:

[0316] The server cleanses the collected or uploaded data. Data cleansing includes removing missing values ​​and formatting the data. Specific examples of operations include "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)". This operation results in formatted data with no missing values. The input is the collected data and uploaded data, and the output is the cleansed data.

[0317] Step 4:

[0318] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process uses machine learning libraries (e.g., TensorFlow, PyTorch). Specific examples of operations include "model.fit(data)" and "model.save('cs_model.h5')." This operation results in a trained AI model. The input is the cleansed data, and the output is the trained AI model.

[0319] Step 5:

[0320] The server uses an emotion engine to extract emotions from the user's input voice or text. The emotion engine uses natural language processing technology and voice analysis technology. Specific examples of operations include "audio_emotion = emotion_engine.analyze_audio(user_input)" for voice input and "text_emotion = emotion_engine.analyze_text(user_input)" for text input. This operation yields the extracted emotion data. The input is the user's voice or text, and the output is emotion data.

[0321] Step 6:

[0322] The server uses a trained AI model to extract keywords and patterns relevant to a specific scenario. An example is "keywords = model.extract_keywords(data)". This operation yields important keywords and patterns. The input is the trained AI model and cleansed data, and the output is the extracted keywords and patterns.

[0323] Step 7:

[0324] The server uses a generative AI model based on the extracted information to automatically generate a complaint handling manual. The generated manual includes specific response procedures and points to note, and the content and tone are adjusted based on the recognized emotions. An example of a specific operation is "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)". This operation results in a generated complaint handling manual. The input is the extracted keywords, patterns, and emotion data, and the output is the generated manual.

[0325] Step 8:

[0326] The server saves the generated manual in a database or storage. An example is "save_manual_db('manual_2023_01', manual_text)". This operation saves the complaint handling manual. The input is the generated manual, and the output is the manual stored in the database.

[0327] Step 9:

[0328] A user (new employee) searches for a specific complaint handling method through the user interface. An example of a specific prompt sentence is "search_manual('The product arrived damaged')". This operation searches for the relevant complaint handling manual. The input is the search query, and the output is the search results.

[0329] Step 10:

[0330] The terminal sends a request to the server, retrieves the relevant manual, and displays it. The server executes the query "SELECT FROM manuals WHERE keywords LIKE '%product is damaged%'" and returns the results to the terminal. The results are displayed on the terminal in the form of "display_manual(result)". This operation provides the user with the procedure to follow. The input is the search results, and the output is the displayed manual.

[0331] (Application example 2)

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

[0333] Conventional complaint handling systems have the problem of being difficult to recognize customer emotions and respond appropriately. Furthermore, generating response procedures is slow, which makes new employees feel uneasy about handling complaints, especially in physical stores, where speed is required. Furthermore, the lack of voice input, which requires manual input, reduces the efficiency and accuracy of responses.

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

[0335] In this invention, the server includes a means for collecting past customer service data, a means for using generative artificial intelligence to learn from the collected customer service data, a means for voice input of the complaint details, a means for analyzing the customer's emotional state during the complaint handling process, and a means for including optimal response procedures in a complaint handling manual based on the analysis results. This enables improved efficiency and accuracy in complaint handling. Furthermore, by recognizing customer emotions in real time and providing optimal response procedures accordingly, improved customer satisfaction can be expected.

[0336] "Past customer service data" refers to all past data related to the customer service provided by a company, including, for example, complaint details, response history, and customer feedback.

[0337] "Means of collection" refers to the technological methods or devices used to obtain historical customer service data from a company's database or other data storage.

[0338] "Generative artificial intelligence" refers to artificial intelligence that has the ability to generate new information or manuals based on existing data, and includes, for example, machine learning models and natural language generation models.

[0339] "Means of learning" refers to the processing technology that inputs collected data into generative artificial intelligence and allows it to recognize patterns and trends.

[0340] "Means for automatically generating complaint handling manuals" refers to technology that automatically creates response procedures and guidelines for specific scenarios based on learned data.

[0341] "Means for storage" refers to the technology used to store the generated complaint handling manual in a database or storage device.

[0342] "User Interface" means the interface that enables a user to interact with a system and enter, retrieve, and display information.

[0343] "Means for searching and displaying" refers to a technology for searching the generated complaint handling manual through a user interface and displaying the results to the user.

[0344] "Voice input means" refers to the technology used to convert speech into text and input it into the system.

[0345] "Means for analyzing the emotional state of customers" refers to technology for recognizing and analyzing customer emotions from the content of complaints and conversations.

[0346] "Means including optimal response procedures" refers to the technology of incorporating appropriate response procedures into a complaint handling manual based on the analysis results.

[0347] The system for implementing this invention is composed of the following main modules. These modules work together to improve the quality of complaint handling.

[0348] 1. Data Collection Module

[0349] The server collects historical customer service data from the company's database. Specifically, it uses SQL queries to extract relevant data and imports it into the system. Administrators can also upload new data, for example in CSV file format. This additional data is used in the data processing module, which is described later.

[0350] 2. Data Processing Module

[0351] The server cleanses the collected data, removing missing values, and performs other formatting operations. The cleansed data is then fed into a generative artificial intelligence (AI) model to learn patterns and important keywords. This training process uses machine learning libraries (such as TensorFlow and PyTorch).

[0352] 3. Emotion Engine Module

[0353] The server converts the speech to text using a speech recognition API (such as Google® Cloud Speech-to-Text). The converted text is then fed into an emotion engine, which uses natural language processing and speech analysis techniques to recognize emotional states (e.g., anger or sadness). This emotion data is then used in the manual generation process described below.

[0354] 4. Manual Generation Module

[0355] The server uses a trained generative AI model (e.g., OpenAI's GPT-3) to automatically generate a response manual based on a complaint scenario. This response procedure is adjusted based on the extracted keywords and recognized emotions. Depending on the emotional state, a particularly polite and careful response procedure may be incorporated.

[0356] 5. User Interface Module

[0357] Users (such as new employees) can use a smartphone, smart glasses, or head-mounted display to voice-input the details of a complaint. The voice data is sent to the server, and an appropriate response manual is then generated through the above-mentioned module. This manual is displayed through the user interface, allowing the user to respond based on the contents in real time.

[0358] As a concrete example, consider a case where a new employee uses smart glasses to handle complaints.

[0359] 1. The store clerk (user) says, "The product arrived broken."

[0360] 2. The server converts the speech to text and analyzes the sentiment using an emotion engine.

[0361] 3. The emotion engine detects "anger" and uses a generative AI model to generate an appropriate response manual.

[0362] 4. Specific instructions for how to proceed will be displayed on the smart glasses, such as "We apologize. We will immediately process your product exchange."

[0363] Example prompt sentence:

[0364] Complaint: The product arrived broken.

[0365] Customer Emotion: Anger

[0366] Generate the corresponding manual:

[0367] In this way, complaints can be dealt with promptly and appropriately, leading to improved customer satisfaction.

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

[0369] Step 1:

[0370] Data collection

[0371] The server collects historical customer service data from the company's database. Specifically, the server issues an SQL query (e.g., "SELECT FROM cs_responses WHERE date > '2022-01-01'") to retrieve relevant data. This allows data such as complaint details and response history to be collected. The input is the SQL query, and the output is a set of customer service data.

[0372] Step 2:

[0373] Uploading additional data

[0374] A user (administrator) uploads new complaint response data to the system. The file is provided in CSV format and is added to the system using the command (e.g., "upload_file('new_cs_responses.csv')"). The input is the new complaint response data file, and the output is the new data added to the database in the system.

[0375] Step 3:

[0376] Data Cleansing

[0377] The server cleanses the collected or uploaded data. It removes missing values ​​and formats the data. Specifically, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)". The input is the collected data filter set, and the output is the cleansed dataset.

[0378] Step 4:

[0379] Data training

[0380] The server then inputs the cleansed data into a generative artificial intelligence (AI) model to learn patterns and important keywords from the data. This process uses machine learning libraries (e.g., TensorFlow, PyTorch) and specific operations such as "model.fit(data)" and "model.save('cs_model.h5')". The input is the cleansed data, and the output is a trained AI model.

[0381] Step 5:

[0382] Voice input

[0383] The user (store clerk) inputs the details of the complaint into a smartphone or smart glasses by voice. This voice data is sent to the server. The input is voice data, and the output is data converted from voice to text.

[0384] Step 6:

[0385] Emotion recognition

[0386] The server inputs the text data of the complaint content into the emotion engine and analyzes the customer's emotions. The emotion engine uses natural language processing and speech analysis technology to recognize emotional states (e.g., anger, sadness, joy, etc.). The input is the text data of the complaint content, and the output is the analyzed emotion data.

[0387] Step 7:

[0388] Manual Generation

[0389] The server uses a trained generative AI model to automatically generate a response manual based on a complaint scenario. Based on the complaint content and emotional data, it creates a prompt sentence and inputs it into the generative AI model. The generated manual includes specific response procedures such as, "We apologize. We will process the product exchange immediately." The input is the complaint content and emotional data, and the output is the generated response manual.

[0390] Step 8:

[0391] View the manual

[0392] The terminal (smartphone or smart glasses) receives the response manual generated from the server and displays it through the user interface. The user can then respond to the complaint quickly and accurately based on the displayed manual. The input is the generated response manual, and the output is the manual displayed to the user.

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

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

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

[0396] [Second embodiment]

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

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

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

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

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

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

[0403] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

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

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

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

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

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

[0409] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). This system includes a data collection module, a data processing module, a manual generation module, and a user interface (UI) module.

[0410] Data Collection Module

[0411] Data collection

[0412] The server collects historical customer service data from the company's database, including customer inquiries, complaints, feedback, and responses thereto.

[0413] For example, the server executes an SQL query to extract data in the form "SELECT FROM cs_responses WHERE date > '2022-01-01'".

[0414] Uploading additional data

[0415] A user (administrator) uploads new data to the system. This additional data is typically provided in a CSV file format.

[0416] For example, a user adds new data to the system using the command "upload_file('new_cs_responses.csv')".

[0417] Data Processing Module

[0418] Data Cleansing

[0419] The server cleanses the collected or uploaded data, which includes removing missing values ​​and formatting the data.

[0420] For example, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[0421] Data training

[0422] The server then feeds the cleansed data into a generative AI model that learns patterns and important keywords from the data. This process is done using machine learning libraries (e.g., TensorFlow, PyTorch).

[0423] For example, a learning model is constructed using the following commands: "model.fit(data)" and "model.save('cs_model.h5')".

[0424] Manual Generation Module

[0425] Keyword and pattern extraction

[0426] The server uses a trained AI model to extract keywords and patterns relevant to a specific scenario.

[0427] For example, use an AI model to extract frequently occurring keywords using the format "keywords = model.extract_keywords(data)".

[0428] Manual creation

[0429] The server uses a generative AI model to automatically generate a complaint handling manual based on the extracted information. The generated manual includes specific response procedures and important points to note.

[0430] For example, a manual can be generated using the operation "manual_text = gpt.generate_manual(keywords)".

[0431] Saving the manual

[0432] The server stores the generated manual in a database or storage, which serves as the basis for later retrieval and display.

[0433] For example, saving is done in the form "save_manual_db('manual_2023_01', manual_text)".

[0434] User Interface Module

[0435] Search for manuals

[0436] When a user (new employee) wants to know how to handle a specific complaint, he or she enters search keywords through the UI.

[0437] For example, a user searches the system using the following format: "search_manual('The product arrived damaged')".

[0438] View the manual

[0439] The terminal sends a request to the server to retrieve and display the relevant manual.

[0440] For example, the server searches for related manual entries and returns the results to the terminal as "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'". The results are displayed on the terminal as "display_manual(result)".

[0441] As a concrete example, when a new employee responds to a complaint that "the product arrived damaged," the user first searches for the problem in the UI. The server retrieves the relevant manual from the database and displays it on the terminal. The new employee can then refer to the displayed manual and handle the complaint by following specific procedures, such as taking a photo, completing the return procedure, and arranging for a replacement. In this way, complaints are handled quickly and in a unified manner, leading to improved customer satisfaction.

[0442] The processing flow will be explained below.

[0443] Step 1:

[0444] The server collects historical customer service data from the company's database by issuing an SQL query to the database, such as "SELECT FROM cs_responses WHERE date > '2022-01-01'".

[0445] Step 2:

[0446] A user (administrator) uploads new complaint response data to the system. The uploaded data is provided in a CSV file format, and the user adds the file to the system using the command "upload_file('new_cs_responses.csv')".

[0447] Step 3:

[0448] The server cleanses the uploaded data. This includes removing missing values ​​and formatting the data. For example, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[0449] Step 4:

[0450] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process is done using machine learning libraries (e.g., TensorFlow, PyTorch). For example, the learning model is built using "model.fit(data)" or "model.save('cs_model.h5')".

[0451] Step 5:

[0452] The server uses the trained AI model to extract keywords and patterns relevant to a specific scenario from historical customer service data. For example, the AI ​​model can be used to extract frequently occurring keywords using the formula "keywords = model.extract_keywords(data)".

[0453] Step 6:

[0454] The server automatically generates a complaint handling manual using a generative AI model based on the extracted keywords and patterns. The generated manual includes specific response procedures and important points to note. For example, a manual can be generated using the operation "manual_text = gpt.generate_manual(keywords)".

[0455] Step 7:

[0456] The server saves the generated manual in a database or storage. This saved manual serves as the basis for later searching and display. For example, it is saved in the form of "save_manual_db('manual_2023_01', manual_text)".

[0457] Step 8:

[0458] A user (new employee) searches for a specific complaint handling method through the user interface. For example, the user searches the system using the form "search_manual('The product arrived damaged')".

[0459] Step 9:

[0460] The terminal sends a request to the server to retrieve and display the relevant manual. The server executes the SQL query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" to search for the relevant manual and returns the results to the terminal. The result is displayed on the terminal as "display_manual(result)".

[0461] Step 10:

[0462] The user (new employee) refers to the displayed manual and follows specific complaint handling procedures. For example, in the case of a damaged product, the user can practice procedures such as "have a photo taken," "proceed with the return shipping," and "arrange for a replacement."

[0463] Example 1

[0464] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0465] Conventional complaint handling systems have had problems with insufficient use of past customer service data, resulting in a lack of quality and speed in responses. Furthermore, the creation of response manuals is often manual, resulting in inefficiency and a lack of consistency. The present invention aims to solve these problems by providing a system that automatically generates prompt and appropriate complaint handling manuals while effectively utilizing past data.

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

[0467] In this invention, the server includes means for collecting past customer service data, means for uploading the collected customer service data, means for cleansing the uploaded data, means for learning the cleansed data using generative artificial intelligence, means for extracting keywords and patterns related to a specific scenario based on the learning results, means for automatically generating a complaint handling manual based on the extracted information, means for saving the generated complaint handling manual, and means for searching for and displaying the generated complaint handling manual via a user interface. This enables the effective use of past data to automatically generate a complaint handling manual that is quick and consistent.

[0468] "Past customer service data" refers to data that includes information about customer service, such as inquiries, complaints, feedback, and responses thereto from past customers.

[0469] "Means of collection" refers to the processes and tools used to obtain historical customer service data from a company's database.

[0470] "Means of uploading" refers to the operations or interface that a user (administrator) uses to add new data to the system.

[0471] "Cleansing measures" refers to processes used to remove missing values ​​or format collected or uploaded data.

[0472] "Generative AI" refers to an AI technology that can learn patterns and important keywords from input data and generate new information based on that.

[0473] "Means of learning" refers to the process by which generative AI uses cleansed data to learn patterns and important keywords from the data.

[0474] "Means for extracting keywords and patterns relevant to a specific scenario" refers to the process of using the learning results to extract important keywords and patterns necessary to respond to a specific situation.

[0475] A "complaint handling manual" refers to a guideline that lists procedures and precautions for handling customer complaints.

[0476] "Means for automatic generation" refers to the process of automatically creating a complaint handling manual based on the extracted information using generative artificial intelligence.

[0477] "Means for storage" refers to the processes and tools for storing the generated complaint handling manual in a database or other storage.

[0478] "User interface" refers to the screen and input means through which a user interacts with a system.

[0479] "Means for searching and displaying" refers to the process or tool that allows a user to find a specific complaint handling manual and display it on a terminal.

[0480] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). The system includes a data collection module, a data processing module, a manual generation module, and a user interface (UI) module.

[0481] Data Collection Module

[0482] The server connects to the company's database to collect historical customer service data. This data can be collected using SQL queries. For example, the query "SELECT FROM cs_responses WHERE date > '2022-01-01'" is executed to retrieve the data. The collected data is stored in the system's memory.

[0483] Uploading additional data

[0484] When a user (administrator) uploads new data to the system, they use a file, such as a CSV file. The upload operation is performed using the system's UI, and data is added using a command such as "upload_file('new_cs_responses.csv')". Once the upload is complete, the system validates the new data and merges it with the existing data.

[0485] Data Processing Module

[0486] The server cleanses the collected or uploaded data. This process includes removing missing values ​​and formatting the data. Specifically, it reads the data with "data = pd.read_csv('new_cs_responses.csv')" and removes missing data with "data.dropna(inplace=True)". The cleansed data is saved for the next learning step.

[0487] Data training

[0488] The server inputs the cleansed data into a generative AI model to learn patterns and important keywords. This uses machine learning libraries (e.g., TensorFlow, PyTorch). For example, run "model.fit(data)" to train the model, and then run "model.save('cs_model.h5')" to save the trained model. This process enables the AI ​​model to extract useful patterns and keywords from past claim data.

[0489] Manual Generation Module

[0490] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. For example, it runs the code "keywords = model.extract_keywords(data)" to extract frequently occurring keywords. Next, a complaint handling manual is automatically generated by the generative AI model based on the extracted keywords. Specifically, the manual is generated using the operation "manual_text = gpt.generate_manual(keywords)". This manual includes specific procedures and reference information for handling complaints.

[0491] Saving the manual

[0492] The server saves the generated manual in a database or storage. For example, it executes the code "save_manual_db('manual_2023_01', manual_text)" to save the manual. The saved manual is structured so that it can be easily searched and displayed later.

[0493] User Interface Module

[0494] When a user (new employee) wants to know how to handle a specific complaint, they enter search keywords through the UI. For example, they enter the search query "search_manual('The product arrived damaged')". The server receives this request and searches the database for relevant manuals.

[0495] The terminal sends a request to the server to retrieve and display the related manual. For example, the server executes the query "SELECT FROM manuals WHERE keywords LIKE '%product is damaged%'" and sends the result to the terminal. The terminal executes the code "display_manual(result)" to display the contents of the related manual to the user.

[0496] An example prompt might be, "What is the procedure for handling a damaged product?" This process allows users to quickly find how to handle a specific complaint and follow the procedure.

[0497] As a concrete example, when a new employee responds to a complaint that "the product arrived damaged," the user first inputs the problem details into the UI, searches for it, and then follows the procedure based on the manual that is displayed. This allows complaints to be handled quickly and in a consistent manner, which is expected to improve customer satisfaction.

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

[0499] Step 1:

[0500] Data collection

[0501] The server connects to the company's database and retrieves historical customer service data.

[0502] Input: Your company's database connection information and query (e.g., "SELECT FROM cs_responses WHERE date > '2022-01-01'").

[0503] Output: The retrieved customer service data.

[0504] How it works: The server executes an SQL query to extract data from the database for a specified period of time, which is then loaded into memory for further processing.

[0505] Step 2:

[0506] Uploading additional data

[0507] The user (administrator) uploads new data to the system.

[0508] Input: New data file (e.g. "new_cs_responses.csv" in CSV format).

[0509] Output: The new data uploaded.

[0510] How it works: A user adds new data to the system by executing the command "upload_file('new_cs_responses.csv')" through the system's UI. Once the file is uploaded, the system validates the new data and integrates it into the existing dataset.

[0511] Step 3:

[0512] Data Cleansing

[0513] The server cleanses the collected or uploaded data.

[0514] Input: Data collected or uploaded.

[0515] Output: The cleansed data.

[0516] Operation: The server executes the code "data = pd.read_csv('new_cs_responses.csv')" to read the data, executes "data.dropna(inplace=True)" to remove missing data, formats the data, and proceeds to the next step.

[0517] Step 4:

[0518] Data training

[0519] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data.

[0520] Input: Cleansed data.

[0521] Output: A trained AI model.

[0522] How it works: The server uses a machine learning library (e.g., TensorFlow, PyTorch) to run "model.fit(data)" to train the data. Once training is complete, it saves the model with "model.save('cs_model.h5')". This allows the AI ​​model to learn useful patterns and keywords from past claim data.

[0523] Step 5:

[0524] Keyword and pattern extraction

[0525] The server uses a trained AI model to extract keywords and patterns relevant to a specific scenario.

[0526] Input: Cleansed data and a trained AI model.

[0527] Output: Extracted keywords and patterns.

[0528] How it works: The server runs the code "keywords = model.extract_keywords(data)" to extract important keywords and patterns from the data that are relevant to the specific scenario. These results are used in the next manual generation step.

[0529] Step 6:

[0530] Manual creation

[0531] Based on the extracted keywords and patterns, the server automatically generates a complaint handling manual using a generative AI model.

[0532] Input: Extracted keywords and patterns.

[0533] Output: Automatically generated complaint handling manual.

[0534] Operation: The server executes the code "manual_text = gpt.generate_manual(keywords)" to generate a complaint handling manual. The generated manual includes specific response procedures and important points to note.

[0535] Step 7:

[0536] Saving the manual

[0537] The server stores the generated complaint handling manual in a database or storage.

[0538] Input: Generated complaint handling manual.

[0539] Output: Manuals stored in a database or storage.

[0540] What happens: The server runs the code "save_manual_db('manual_2023_01', manual_text)" to save the manual to the database, laying the groundwork for later retrieval and display.

[0541] Step 8:

[0542] Search for manuals

[0543] When a user (new employee) wants to know how to handle a specific complaint, he or she enters search keywords through the UI.

[0544] Input: Search keywords (e.g. "The product arrived damaged").

[0545] Output: Related complaint handling manual.

[0546] How it works: A user enters a search query via the UI: "search_manual('The product arrived damaged')". The server receives the request and searches the database for the corresponding manual.

[0547] Step 9:

[0548] View the manual

[0549] The terminal sends a request to the server to retrieve and display the relevant manual.

[0550] Input: Search results received from the server.

[0551] Output: Complaint handling manual displayed on the terminal.

[0552] Operation: The server executes the query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" to retrieve the relevant manual. The terminal executes the code "display_manual(result)" to display the contents of the relevant manual to the user.

[0553] (Application example 1)

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

[0555] While automated production lines in modern factories have significantly improved efficiency, they can also have a negative impact on productivity if unexpected errors or complaints are not dealt with promptly. Furthermore, it is difficult for new staff to deal with these issues quickly and accurately, leading to the risk of delayed responses or inappropriate handling. This invention aims to respond quickly and effectively to errors and complaints that occur on production lines, reducing the burden on staff while maintaining production efficiency.

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

[0557] In this invention, the server includes means for collecting past customer service data, means for using generative artificial intelligence to learn the collected customer service data, means for automatically generating a complaint handling manual based on the learning results, means for saving the generated complaint handling manual, means for searching and displaying the generated complaint handling manual via a user interface, and means for generating a manual for resolving errors and complaints that occur in the automation system in the factory. This enables a quick and unified response to errors and complaints that occur in the factory.

[0558] "Historical customer service data" refers to data that a company collects and stores, such as information about customer service inquiries, complaints, feedback, and responses to such inquiries and complaints.

[0559] "Means of collection" refers to the process or mechanism by which the required customer service data is obtained from a company's database.

[0560] "Generative artificial intelligence" refers to AI systems that have the ability to analyze collected data, learn, and generate new information and answers.

[0561] A "complaint handling manual" is a document that lists specific procedures and points to note when dealing with complaints and inquiries from customers.

[0562] "Means for storage" refers to a system for properly storing the generated complaint handling manual in a database or storage for a certain period of time.

[0563] "User interface" refers to the software and hardware configuration that allows a user to interact with a system, and specifically includes a screen, input device, and the like.

[0564] "Means for searching and displaying" refers to a function for searching the complaint handling manual stored in the database as needed and visually displaying the results to the user.

[0565] "Factory automation system" refers to an integrated system of hardware and software for automatically executing manufacturing processes.

[0566] "Means for generating manuals for resolving errors and complaints" refers to a mechanism for automatically creating resolution procedures based on past data for problems that occur in automated systems within a factory.

[0567] As an embodiment of the present invention, a specific system implementation for dealing with errors and complaints in an automation system within a factory will be described below.

[0568] The system includes a data collection module for collecting past customer service data, a data processing module for cleansing and formatting the collected data, a manual generation module for automatically generating complaint handling manuals using generative artificial intelligence, a UI module for searching and displaying saved manuals via a user interface, and a means for quickly responding to errors and complaints that occur in the automation systems within the factory.

[0569] The server first collects past customer service data from the company's database. Specifically, it executes SQL queries to extract the necessary data from the database. The range and format of data to be collected are set by default. The server also provides a means for users to upload new data, ensuring that the system is always running with the latest data.

[0570] The collected data is then cleansed and formatted by a data processing module, which uses Python and Pandas to remove missing values ​​and standardize the data format, allowing the generative artificial intelligence to learn efficiently.

[0571] After the data is prepared, the server uses generative AI (for example, GPT-3 or TensorFlow) to automatically generate a complaint handling manual from the data. The generative AI learns from the data and generates a new manual based on past error resolution methods and complaint handling procedures.

[0572] The generated complaint handling manual is stored in server storage, which provides the foundation for later retrieval and display. A user interface (e.g., a web interface using Flask) is provided, through which users can search for response procedures based on specific errors or complaints.

[0573] As an actual usage example, consider the case where a robot in a factory stops working. In this case, the user enters a complaint, such as "The robot arm has stopped," into the interface and searches. The server searches the database for the relevant complaint handling manual and displays the generated procedure on the user's device. This allows the user to solve the problem quickly and accurately.

[0574] An example of an actual prompt is as follows:

[0575] text

[0576] Generate a complaint handling manual: The robot arm has stopped

[0577] In this way, the present invention is a system that enables a quick and unified response to errors and complaints that occur in the automation system within a factory, maintaining production efficiency while reducing the burden on staff.

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

[0579] Step 1: Data collection

[0580] The server collects historical customer service data from the company's database. It uses SQL queries to select data that matches certain criteria. For example, it executes a query like "SELECT FROM cs_responses WHERE date > '2022-01-01'." The input is the customer service data stored in the database, and the output is a list of data that matches the query. Users can also upload new data; in this case, the additional data is uploaded to the server in CSV format. The server then merges this new data with the existing data.

[0581] Step 2: Cleanse and shape the data

[0582] The server cleanses and formats the collected data using Python and the Pandas library. This involves removing missing values ​​and standardizing the data format. For example, "data.dropna(inplace=True)" is used to remove missing values, and then the data is formatted. The input to this step is the collected customer service data, and the output is the cleansed and formatted data.

[0583] Step 3: Train the data

[0584] The server inputs the cleansed data into a generative AI model for learning. The generative AI model used is TensorFlow, which learns patterns and important keywords from the data. Specifically, learning proceeds using "model.fit(data)", and then the model is saved using "model.save('cs_model.h5')". The input is the cleansed and formatted data, and the output is the trained AI model.

[0585] Step 4: Extracting keywords and patterns

[0586] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. Specifically, it extracts frequently occurring keywords using the formula "keywords = model.extract_keywords(data)". The input for this step is the trained AI model and newly provided scenario data, and the output is specific keywords and patterns.

[0587] Step 5: Automatic generation of manuals

[0588] The server automatically generates a complaint handling manual using a generative AI model based on the extracted keywords and patterns. In this case, it is common to use GPT-3 as the generative AI model. Specifically, the manual is generated using "manual_text = gpt.generate_manual(keywords)". The input is specific keywords and patterns, and the output is the generated complaint handling manual.

[0589] Step 6: Save the manual

[0590] The server saves the generated complaint handling manual in a database or storage. For example, it is saved as "save_manual_db('manual_2023_01', manual_text)". The input of this step is the generated manual, and the output is the manual saved in the database.

[0591] Step 7: Search and view the documentation

[0592] When a user wants to know how to handle a particular complaint, they enter relevant keywords through the user interface. The server searches the database for relevant manuals based on those keywords and displays them on the user's terminal. For example, if a user searches for "search_manual('The robot arm has stopped')", the server searches as "SELECT FROM manuals WHERE keywords LIKE '%robot arm%'" and returns the results to the user's terminal, which displays them as "display_manual(result)". The input to this step is the keyword entered by the user, and the output is the relevant manual displayed on the user's terminal.

[0593] Through these steps, this system enables a quick and unified response to errors and complaints that occur in the automation systems within a factory.

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

[0595] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). Furthermore, this system incorporates an emotion engine that recognizes user emotions, enabling the quality of complaint handling to be improved based on emotions. This system includes a data collection module, a data processing module, a manual generation module, an emotion engine module, and a user interface (UI) module.

[0596] Data Collection Module

[0597] Data collection

[0598] The server collects historical customer service data from the company's database by issuing an SQL query to the database, such as "SELECT FROM cs_responses WHERE date > '2022-01-01'".

[0599] Uploading additional data

[0600] A user (administrator) uploads new complaint response data to the system. The uploaded data is provided in a CSV file format, and the user adds the file to the system using the command "upload_file('new_cs_responses.csv')".

[0601] Data Processing Module

[0602] Data Cleansing

[0603] The server cleanses the collected or uploaded data. This includes removing missing values ​​and formatting the data. For example, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[0604] Data training

[0605] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process is done using machine learning libraries (e.g., TensorFlow, PyTorch). For example, the learning model is built using "model.fit(data)" or "model.save('cs_model.h5')".

[0606] Emotion Engine Module

[0607] Emotion recognition

[0608] The server uses an emotion engine to extract emotions from the user's input voice or text. The emotion engine uses natural language processing and speech analysis technologies to recognize emotional states such as anger, sadness, and joy.

[0609] For example, for voice input, emotions are analyzed using "audio_emotion = emotion_engine.analyze_audio(user_input)", and for text input, emotions are analyzed using "text_emotion = emotion_engine.analyze_text(user_input)".

[0610] Manual Generation Module

[0611] Keyword and pattern extraction

[0612] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. For example, the AI ​​model can be used to extract frequently occurring keywords using the format "keywords = model.extract_keywords(data)".

[0613] Manual creation

[0614] The server uses a generative AI model to automatically generate a complaint handling manual based on the extracted information. The generated manual includes specific response procedures and important points to note. The content and tone of the manual are also adjusted based on the recognized emotions.

[0615] For example, if the user is feeling angry, a particularly polite and careful response procedure can be incorporated. The manual is generated using the operation "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)".

[0616] Saving the manual

[0617] The server saves the generated manual in a database or storage. This saved manual serves as the basis for later searching and display. For example, it is saved in the form of "save_manual_db('manual_2023_01', manual_text)".

[0618] User Interface Module

[0619] Search for manuals

[0620] A user (new employee) searches for a specific complaint handling method through the user interface. For example, the user searches the system using the form "search_manual('The product arrived damaged')".

[0621] View the manual

[0622] The terminal sends a request to the server to retrieve and display the relevant manual. The server executes the SQL query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" to search for the relevant manual and returns the results to the terminal. The result is displayed on the terminal as "display_manual(result)".

[0623] Specific examples

[0624] For example, when a new employee responds to a complaint that "the product arrived damaged," the process would be as follows:

[0625] 1. A user (new employee) accepts a complaint and searches for the problem using the user interface.

[0626] 2. The server extracts appropriate keywords based on past data and generates a corresponding manual based on them.

[0627] 3. The emotion engine recognizes the user's (customer's) emotions and reflects them in the manual. For example, if a customer is angry, a particularly polite and prompt response procedure is required.

[0628] 4. The terminal displays the generated manual, and the user refers to it and takes appropriate action.

[0629] In this way, complaints can be dealt with promptly and appropriately, leading to improved customer satisfaction.

[0630] The processing flow will be explained below.

[0631] Step 1:

[0632] The server collects past customer service data from the company's database. Specifically, the server issues the SQL query "SELECT FROM cs_responses WHERE date > '2022-01-01'" to extract the target data from the database.

[0633] Step 2:

[0634] The user (administrator) uploads new complaint response data to the system. To upload, use the command "upload_file('new_cs_responses.csv')" to add data in CSV file format.

[0635] Step 3:

[0636] The server cleanses the uploaded data. It uses Python or similar tools to remove missing values ​​and format the data. For example, it uses operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[0637] Step 4:

[0638] The server inputs the cleansed data into a generative AI model, and uses machine learning libraries (e.g., TensorFlow, PyTorch) to learn patterns and important keywords from the data. Specifically, the learning model is constructed using commands such as "model.fit(data)" and "model.save('cs_model.h5')."

[0639] Step 5:

[0640] The server uses the emotion engine to extract emotions from the user's input voice or text. The emotion engine recognizes the user's emotional state using natural language processing and voice analysis technology. Specifically, for voice input, it performs the operation "audio_emotion = emotion_engine.analyze_audio(user_input)", and for text input, it performs the operation "text_emotion = emotion_engine.analyze_text(user_input)".

[0641] Step 6:

[0642] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. For example, it obtains frequently occurring keywords using the format "keywords = model.extract_keywords(data)".

[0643] Step 7:

[0644] The server uses a generative AI model to automatically generate a complaint handling manual based on the extracted keywords and the emotions recognized by the emotion engine. For example, if the user is feeling angry, a manual is created that includes polite and careful response procedures. The manual is generated using the operation "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)".

[0645] Step 8:

[0646] The server saves the generated manual to a database or storage. This is done in the form of "save_manual_db('manual_2023_01', manual_text)".

[0647] Step 9:

[0648] A user (new employee) searches for a specific complaint handling method through the user interface. For example, they search the system using the form "search_manual('The product arrived damaged')".

[0649] Step 10:

[0650] The terminal sends a request to the server to retrieve and display the relevant manual. The server executes the SQL query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" and returns the results to the terminal. The terminal displays the manual in the form of "display_manual(result)".

[0651] Step 11:

[0652] The user (new employee) refers to the displayed manual and follows specific procedures for handling complaints. For example, in response to a complaint that a product was delivered damaged, the user takes a photo, goes through the return procedure, and arranges for a replacement.

[0653] Example 2

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

[0655] In conventional complaint handling systems, it was difficult to efficiently utilize past customer service data and quickly and appropriately generate customer handling manuals. Furthermore, because handling procedures were determined without taking into account the customer's feelings, it was difficult to improve customer satisfaction. The present invention aims to solve these problems and provide a new system for improving the quality of customer handling.

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

[0657] In this invention, the server includes means for collecting past customer service data, means for shaping and cleansing the collected customer service data, means for learning data using generative artificial intelligence, means for automatically generating a complaint handling manual based on the learning results, means for saving the generated complaint handling manual, means for searching and displaying the generated complaint handling manual via a user interface, and means for recognizing user emotions and adjusting the content of the complaint handling manual based on the recognition results. This makes it possible to efficiently utilize past data and quickly respond appropriately to customer emotions.

[0658] "Past customer service data" refers to historical information such as inquiries, complaints, and response history received by a company from customers.

[0659] "Formatting and cleansing" refers to preprocessing work to improve data quality, such as removing missing values ​​and standardizing the format of data.

[0660] "Generative AI" refers to AI technology that can extract patterns and keywords from data and generate new sentences and content.

[0661] A "complaint handling manual" refers to a guideline or procedure manual that shows the steps that should be taken to respond to customer complaints.

[0662] "Storage" refers to the process of storing the generated complaint handling manual in a database or storage so that it can be reused later.

[0663] The term "user interface" refers to the parts that are directly operated by the user, such as the screen and input method that allow the user to interact with the system.

[0664] "Search and display" refers to the process of locating and finding specific information from a database and presenting the results in a visible form to the user.

[0665] "Emotion recognition" refers to the technology of analyzing and identifying a user's emotional state from their input voice or text.

[0666] "Adjusting the content" refers to the process of changing the content and tone of the complaint handling manual in response to perceived emotions to ensure an appropriate response.

[0667] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). The system includes a data collection module, a data processing module, a manual generation module, an emotion engine module, and a user interface (UI) module.

[0668] Data Collection Module

[0669] The server issues an SQL query to the company's database to collect past customer service data. Specifically, the query format is "SELECT FROM cs_responses WHERE date > '2022-01-01'". Furthermore, the user (administrator) uploads new complaint response data to the system in CSV file format. Specifically, the upload method uses the command "upload_file('new_cs_responses.csv')".

[0670] Data Processing Module

[0671] The server cleanses the collected or uploaded data. Data cleansing includes removing missing values ​​and formatting the data. Specific examples of operations include "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)." The server then inputs the cleansed data into a generative AI model to learn patterns and important keywords from the data. This process uses a machine learning library (e.g., TensorFlow, PyTorch) and executes operations such as "model.fit(data)" and "model.save('cs_model.h5')."

[0672] Emotion Engine Module

[0673] The server uses an emotion engine to extract emotions from the user's input voice or text. The emotion engine uses natural language processing technology and voice analysis technology. Specific examples of operations include "audio_emotion = emotion_engine.analyze_audio(user_input)" for voice input and "text_emotion = emotion_engine.analyze_text(user_input)" for text input.

[0674] Manual Generation Module

[0675] The server uses a trained AI model to extract keywords and patterns related to a specific scenario. An example is "keywords = model.extract_keywords(data)". The server then uses a generative AI model based on the extracted information to automatically generate a complaint handling manual. The generated manual includes specific response procedures and points to note, and the content and tone are adjusted based on the recognized emotions. For example, a manual is generated using the operation "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)". The server then saves the generated manual in a database or storage. An example is "save_manual_db('manual_2023_01', manual_text)".

[0676] User Interface Module

[0677] A user (new employee) searches for a specific complaint handling method via the user interface. An example of a specific prompt sentence is "search_manual('The product arrived damaged')". The terminal then sends a request to the server to retrieve and display the relevant manual. The server executes the query "SELECT FROM manuals WHERE keywords LIKE '%The product arrived damaged%'" and returns the results to the terminal. The results are displayed on the terminal in the form of "display_manual(result)".

[0678] Specific examples

[0679] For example, if a new employee is responding to a complaint that "the product arrived damaged," the user (new employee) accepts the complaint and uses the user interface to search for the problem. They enter the prompt "search_manual('The product arrived damaged')." The server extracts appropriate keywords from past data and generates a response manual based on those keywords. Furthermore, an emotion engine recognizes the user's (customer's) emotions and reflects them in the manual content. For example, if the customer is angry, a particularly polite and prompt response procedure is required. The terminal displays the generated manual, and the user refers to it to respond. This process enables a quick and accurate response to the complaint, leading to improved customer satisfaction.

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

[0681] Step 1:

[0682] The server issues an SQL query to the company's database to collect historical customer service data. Specifically, it executes the query "SELECT FROM cs_responses WHERE date > '2022-01-01'". This operation pulls historical customer service data into the server. The input is the database query result, and the output is the collected customer service data.

[0683] Step 2:

[0684] The user (administrator) uploads new complaint response data to the system in CSV file format. The specific upload method is to use the command "upload_file('new_cs_responses.csv')". This operation adds the new complaint response data to the system. The input is the CSV file, and the output is the new data saved in the system.

[0685] Step 3:

[0686] The server cleanses the collected or uploaded data. Data cleansing includes removing missing values ​​and formatting the data. Specific examples of operations include "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)". This operation results in formatted data with no missing values. The input is the collected data and uploaded data, and the output is the cleansed data.

[0687] Step 4:

[0688] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process uses machine learning libraries (e.g., TensorFlow, PyTorch). Specific examples of operations include "model.fit(data)" and "model.save('cs_model.h5')." This operation results in a trained AI model. The input is the cleansed data, and the output is the trained AI model.

[0689] Step 5:

[0690] The server uses an emotion engine to extract emotions from the user's input voice or text. The emotion engine uses natural language processing technology and voice analysis technology. Specific examples of operations include "audio_emotion = emotion_engine.analyze_audio(user_input)" for voice input and "text_emotion = emotion_engine.analyze_text(user_input)" for text input. This operation yields the extracted emotion data. The input is the user's voice or text, and the output is emotion data.

[0691] Step 6:

[0692] The server uses a trained AI model to extract keywords and patterns relevant to a specific scenario. An example is "keywords = model.extract_keywords(data)". This operation yields important keywords and patterns. The input is the trained AI model and cleansed data, and the output is the extracted keywords and patterns.

[0693] Step 7:

[0694] The server uses a generative AI model based on the extracted information to automatically generate a complaint handling manual. The generated manual includes specific response procedures and points to note, and the content and tone are adjusted based on the recognized emotions. An example of a specific operation is "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)". This operation results in a generated complaint handling manual. The input is the extracted keywords, patterns, and emotion data, and the output is the generated manual.

[0695] Step 8:

[0696] The server saves the generated manual in a database or storage. An example is "save_manual_db('manual_2023_01', manual_text)". This operation saves the complaint handling manual. The input is the generated manual, and the output is the manual stored in the database.

[0697] Step 9:

[0698] A user (new employee) searches for a specific complaint handling method through the user interface. An example of a specific prompt sentence is "search_manual('The product arrived damaged')". This operation searches for the relevant complaint handling manual. The input is the search query, and the output is the search results.

[0699] Step 10:

[0700] The terminal sends a request to the server, retrieves the relevant manual, and displays it. The server executes the query "SELECT FROM manuals WHERE keywords LIKE '%product is damaged%'" and returns the results to the terminal. The results are displayed on the terminal in the form of "display_manual(result)". This operation provides the user with the procedure to follow. The input is the search results, and the output is the displayed manual.

[0701] (Application example 2)

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

[0703] Conventional complaint handling systems have the problem of being difficult to recognize customer emotions and respond appropriately. Furthermore, generating response procedures is slow, which makes new employees feel uneasy about handling complaints, especially in physical stores, where speed is required. Furthermore, the lack of voice input, which requires manual input, reduces the efficiency and accuracy of responses.

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

[0705] In this invention, the server includes a means for collecting past customer service data, a means for using generative artificial intelligence to learn from the collected customer service data, a means for voice input of the complaint details, a means for analyzing the customer's emotional state during the complaint handling process, and a means for including optimal response procedures in a complaint handling manual based on the analysis results. This enables improved efficiency and accuracy in complaint handling. Furthermore, by recognizing customer emotions in real time and providing optimal response procedures accordingly, improved customer satisfaction can be expected.

[0706] "Past customer service data" refers to all past data related to the customer service provided by a company, including, for example, complaint details, response history, and customer feedback.

[0707] "Means of collection" refers to the technological methods or devices used to obtain historical customer service data from a company's database or other data storage.

[0708] "Generative artificial intelligence" refers to artificial intelligence that has the ability to generate new information or manuals based on existing data, and includes, for example, machine learning models and natural language generation models.

[0709] "Means of learning" refers to the processing technology that inputs collected data into generative artificial intelligence and allows it to recognize patterns and trends.

[0710] "Means for automatically generating complaint handling manuals" refers to technology that automatically creates response procedures and guidelines for specific scenarios based on learned data.

[0711] "Means for storage" refers to the technology used to store the generated complaint handling manual in a database or storage device.

[0712] "User Interface" means the interface that enables a user to interact with a system and enter, retrieve, and display information.

[0713] "Means for searching and displaying" refers to a technology for searching the generated complaint handling manual through a user interface and displaying the results to the user.

[0714] "Voice input means" refers to the technology used to convert speech into text and input it into the system.

[0715] "Means for analyzing the emotional state of customers" refers to technology for recognizing and analyzing customer emotions from the content of complaints and conversations.

[0716] "Means including optimal response procedures" refers to the technology of incorporating appropriate response procedures into a complaint handling manual based on the analysis results.

[0717] The system for implementing this invention is composed of the following main modules. These modules work together to improve the quality of complaint handling.

[0718] 1. Data Collection Module

[0719] The server collects historical customer service data from the company's database. Specifically, it uses SQL queries to extract relevant data and imports it into the system. Administrators can also upload new data, for example in CSV file format. This additional data is used in the data processing module, which is described later.

[0720] 2. Data Processing Module

[0721] The server cleanses the collected data, removing missing values, and performs other formatting operations. The cleansed data is then fed into a generative artificial intelligence (AI) model to learn patterns and important keywords. This training process uses machine learning libraries (such as TensorFlow and PyTorch).

[0722] 3. Emotion Engine Module

[0723] The server converts the speech to text using a speech recognition API (such as Google Cloud Speech-to-Text). The converted text is then fed into an emotion engine, which uses natural language processing and speech analysis techniques to recognize emotional states (e.g., anger or sadness). This emotion data is then used in the manual generation process described below.

[0724] 4. Manual Generation Module

[0725] The server uses a trained generative AI model (such as OpenAI's GPT-3) to automatically generate a response manual based on a complaint scenario. This response procedure is adjusted based on the extracted keywords and recognized emotions. Depending on the emotional state, a particularly polite and careful response procedure may be incorporated.

[0726] 5. User Interface Module

[0727] Users (such as new employees) can use a smartphone, smart glasses, or head-mounted display to voice-input the details of a complaint. The voice data is sent to the server, and an appropriate response manual is then generated through the above-mentioned module. This manual is displayed through the user interface, allowing the user to respond based on the contents in real time.

[0728] As a concrete example, consider a case where a new employee uses smart glasses to handle complaints.

[0729] 1. The store clerk (user) says, "The product arrived broken."

[0730] 2. The server converts the speech to text and analyzes the sentiment using an emotion engine.

[0731] 3. The emotion engine detects "anger" and uses a generative AI model to generate an appropriate response manual.

[0732] 4. Specific instructions for how to proceed will be displayed on the smart glasses, such as "We apologize. We will immediately process your product exchange."

[0733] Example prompt sentence:

[0734] Complaint: The product arrived broken.

[0735] Customer Emotion: Anger

[0736] Generate the corresponding manual:

[0737] In this way, complaints can be dealt with promptly and appropriately, leading to improved customer satisfaction.

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

[0739] Step 1:

[0740] Data collection

[0741] The server collects historical customer service data from the company's database. Specifically, the server issues an SQL query (e.g., "SELECT FROM cs_responses WHERE date > '2022-01-01'") to retrieve relevant data. This allows data such as complaint details and response history to be collected. The input is the SQL query, and the output is a set of customer service data.

[0742] Step 2:

[0743] Uploading additional data

[0744] A user (administrator) uploads new complaint response data to the system. The file is provided in CSV format and is added to the system using the command (e.g., "upload_file('new_cs_responses.csv')"). The input is the new complaint response data file, and the output is the new data added to the database in the system.

[0745] Step 3:

[0746] Data Cleansing

[0747] The server cleanses the collected or uploaded data. It removes missing values ​​and formats the data. Specifically, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)". The input is the collected data filter set, and the output is the cleansed dataset.

[0748] Step 4:

[0749] Data training

[0750] The server then inputs the cleansed data into a generative artificial intelligence (AI) model to learn patterns and important keywords from the data. This process uses machine learning libraries (e.g., TensorFlow, PyTorch) and specific operations such as "model.fit(data)" and "model.save('cs_model.h5')". The input is the cleansed data, and the output is a trained AI model.

[0751] Step 5:

[0752] Voice input

[0753] The user (store clerk) inputs the details of the complaint into a smartphone or smart glasses by voice. This voice data is sent to the server. The input is voice data, and the output is data converted from voice to text.

[0754] Step 6:

[0755] Emotion recognition

[0756] The server inputs the text data of the complaint content into the emotion engine and analyzes the customer's emotions. The emotion engine uses natural language processing and speech analysis technology to recognize emotional states (e.g., anger, sadness, joy, etc.). The input is the text data of the complaint content, and the output is the analyzed emotion data.

[0757] Step 7:

[0758] Manual Generation

[0759] The server uses a trained generative AI model to automatically generate a response manual based on a complaint scenario. Based on the complaint content and emotional data, it creates a prompt sentence and inputs it into the generative AI model. The generated manual includes specific response procedures such as, "We apologize. We will process the product exchange immediately." The input is the complaint content and emotional data, and the output is the generated response manual.

[0760] Step 8:

[0761] View the manual

[0762] The terminal (smartphone or smart glasses) receives the response manual generated from the server and displays it through the user interface. The user can then respond to the complaint quickly and accurately based on the displayed manual. The input is the generated response manual, and the output is the manual displayed to the user.

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

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

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

[0766] [Third embodiment]

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

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

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

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

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

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

[0773] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

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

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

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

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

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

[0779] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). This system includes a data collection module, a data processing module, a manual generation module, and a user interface (UI) module.

[0780] Data Collection Module

[0781] Data collection

[0782] The server collects historical customer service data from the company's database, including customer inquiries, complaints, feedback, and responses thereto.

[0783] For example, the server executes an SQL query to extract data in the form "SELECT FROM cs_responses WHERE date > '2022-01-01'".

[0784] Uploading additional data

[0785] A user (administrator) uploads new data to the system. This additional data is typically provided in a CSV file format.

[0786] For example, a user adds new data to the system using the command "upload_file('new_cs_responses.csv')".

[0787] Data Processing Module

[0788] Data Cleansing

[0789] The server cleanses the collected or uploaded data, which includes removing missing values ​​and formatting the data.

[0790] For example, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[0791] Data training

[0792] The server then feeds the cleansed data into a generative AI model that learns patterns and important keywords from the data. This process is done using machine learning libraries (e.g., TensorFlow, PyTorch).

[0793] For example, a learning model is constructed using the following commands: "model.fit(data)" and "model.save('cs_model.h5')".

[0794] Manual Generation Module

[0795] Keyword and pattern extraction

[0796] The server uses a trained AI model to extract keywords and patterns relevant to a specific scenario.

[0797] For example, use an AI model to extract frequently occurring keywords using the format "keywords = model.extract_keywords(data)".

[0798] Manual creation

[0799] The server uses a generative AI model to automatically generate a complaint handling manual based on the extracted information. The generated manual includes specific response procedures and important points to note.

[0800] For example, a manual can be generated using the operation "manual_text = gpt.generate_manual(keywords)".

[0801] Saving the manual

[0802] The server stores the generated manual in a database or storage, which serves as the basis for later retrieval and display.

[0803] For example, saving is done in the form "save_manual_db('manual_2023_01', manual_text)".

[0804] User Interface Module

[0805] Search for manuals

[0806] When a user (new employee) wants to know how to handle a specific complaint, he or she enters search keywords through the UI.

[0807] For example, a user searches the system using the following format: "search_manual('The product arrived damaged')".

[0808] View the manual

[0809] The terminal sends a request to the server to retrieve and display the relevant manual.

[0810] For example, the server searches for related manual entries and returns the results to the terminal as "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'". The results are displayed on the terminal as "display_manual(result)".

[0811] As a concrete example, when a new employee responds to a complaint that "the product arrived damaged," the user first searches for the problem in the UI. The server retrieves the relevant manual from the database and displays it on the terminal. The new employee can then refer to the displayed manual and handle the complaint by following specific procedures, such as taking a photo, completing the return procedure, and arranging for a replacement. In this way, complaints are handled quickly and in a unified manner, leading to improved customer satisfaction.

[0812] The processing flow will be explained below.

[0813] Step 1:

[0814] The server collects historical customer service data from the company's database by issuing an SQL query to the database, such as "SELECT FROM cs_responses WHERE date > '2022-01-01'".

[0815] Step 2:

[0816] A user (administrator) uploads new complaint response data to the system. The uploaded data is provided in a CSV file format, and the user adds the file to the system using the command "upload_file('new_cs_responses.csv')".

[0817] Step 3:

[0818] The server cleanses the uploaded data. This includes removing missing values ​​and formatting the data. For example, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[0819] Step 4:

[0820] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process is done using machine learning libraries (e.g., TensorFlow, PyTorch). For example, the learning model is built using "model.fit(data)" or "model.save('cs_model.h5')".

[0821] Step 5:

[0822] The server uses the trained AI model to extract keywords and patterns relevant to a specific scenario from historical customer service data. For example, the AI ​​model can be used to extract frequently occurring keywords using the formula "keywords = model.extract_keywords(data)".

[0823] Step 6:

[0824] The server automatically generates a complaint handling manual using a generative AI model based on the extracted keywords and patterns. The generated manual includes specific response procedures and important points to note. For example, a manual can be generated using the operation "manual_text = gpt.generate_manual(keywords)".

[0825] Step 7:

[0826] The server saves the generated manual in a database or storage. This saved manual serves as the basis for later searching and display. For example, it is saved in the form of "save_manual_db('manual_2023_01', manual_text)".

[0827] Step 8:

[0828] A user (new employee) searches for a specific complaint handling method through the user interface. For example, the user searches the system using the form "search_manual('The product arrived damaged')".

[0829] Step 9:

[0830] The terminal sends a request to the server to retrieve and display the relevant manual. The server executes the SQL query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" to search for the relevant manual and returns the results to the terminal. The result is displayed on the terminal as "display_manual(result)".

[0831] Step 10:

[0832] The user (new employee) refers to the displayed manual and follows specific complaint handling procedures. For example, in the case of a damaged product, the user can practice procedures such as "have a photo taken," "proceed with the return shipping," and "arrange for a replacement."

[0833] Example 1

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

[0835] Conventional complaint handling systems have had problems with insufficient use of past customer service data, resulting in a lack of quality and speed in responses. Furthermore, the creation of response manuals is often manual, resulting in inefficiency and a lack of consistency. The present invention aims to solve these problems by providing a system that automatically generates prompt and appropriate complaint handling manuals while effectively utilizing past data.

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

[0837] In this invention, the server includes means for collecting past customer service data, means for uploading the collected customer service data, means for cleansing the uploaded data, means for learning the cleansed data using generative artificial intelligence, means for extracting keywords and patterns related to a specific scenario based on the learning results, means for automatically generating a complaint handling manual based on the extracted information, means for saving the generated complaint handling manual, and means for searching for and displaying the generated complaint handling manual via a user interface. This enables the effective use of past data to automatically generate a complaint handling manual that is quick and consistent.

[0838] "Past customer service data" refers to data that includes information about customer service, such as inquiries, complaints, feedback, and responses thereto from past customers.

[0839] "Means of collection" refers to the processes and tools used to obtain historical customer service data from a company's database.

[0840] "Means of uploading" refers to the operations or interface that a user (administrator) uses to add new data to the system.

[0841] "Cleansing measures" refers to processes used to remove missing values ​​or format collected or uploaded data.

[0842] "Generative AI" refers to an AI technology that can learn patterns and important keywords from input data and generate new information based on that.

[0843] "Means of learning" refers to the process by which generative AI uses cleansed data to learn patterns and important keywords from the data.

[0844] "Means for extracting keywords and patterns relevant to a specific scenario" refers to the process of using the learning results to extract important keywords and patterns necessary to respond to a specific situation.

[0845] A "complaint handling manual" refers to a guideline that lists procedures and precautions for handling customer complaints.

[0846] "Means for automatic generation" refers to the process of automatically creating a complaint handling manual based on the extracted information using generative artificial intelligence.

[0847] "Means for storage" refers to the processes and tools for storing the generated complaint handling manual in a database or other storage.

[0848] "User interface" refers to the screen and input means through which a user interacts with a system.

[0849] "Means for searching and displaying" refers to the process or tool that allows a user to find a specific complaint handling manual and display it on a terminal.

[0850] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). The system includes a data collection module, a data processing module, a manual generation module, and a user interface (UI) module.

[0851] Data Collection Module

[0852] The server connects to the company's database to collect historical customer service data. This data can be collected using SQL queries. For example, the query "SELECT FROM cs_responses WHERE date > '2022-01-01'" is executed to retrieve the data. The collected data is stored in the system's memory.

[0853] Uploading additional data

[0854] When a user (administrator) uploads new data to the system, they use a file, such as a CSV file. The upload operation is performed using the system's UI, and data is added using a command such as "upload_file('new_cs_responses.csv')". Once the upload is complete, the system validates the new data and merges it with the existing data.

[0855] Data Processing Module

[0856] The server cleanses the collected or uploaded data. This process includes removing missing values ​​and formatting the data. Specifically, it reads the data with "data = pd.read_csv('new_cs_responses.csv')" and removes missing data with "data.dropna(inplace=True)". The cleansed data is saved for the next learning step.

[0857] Data training

[0858] The server inputs the cleansed data into a generative AI model to learn patterns and important keywords. This uses machine learning libraries (e.g., TensorFlow, PyTorch). For example, run "model.fit(data)" to train the model, and then run "model.save('cs_model.h5')" to save the trained model. This process enables the AI ​​model to extract useful patterns and keywords from past claim data.

[0859] Manual Generation Module

[0860] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. For example, it runs the code "keywords = model.extract_keywords(data)" to extract frequently occurring keywords. Next, a complaint handling manual is automatically generated by the generative AI model based on the extracted keywords. Specifically, the manual is generated using the operation "manual_text = gpt.generate_manual(keywords)". This manual includes specific procedures and reference information for handling complaints.

[0861] Saving the manual

[0862] The server saves the generated manual in a database or storage. For example, it executes the code "save_manual_db('manual_2023_01', manual_text)" to save the manual. The saved manual is structured so that it can be easily searched and displayed later.

[0863] User Interface Module

[0864] When a user (new employee) wants to know how to handle a specific complaint, they enter search keywords through the UI. For example, they enter the search query "search_manual('The product arrived damaged')". The server receives this request and searches the database for relevant manuals.

[0865] The terminal sends a request to the server to retrieve and display the related manual. For example, the server executes the query "SELECT FROM manuals WHERE keywords LIKE '%product is damaged%'" and sends the result to the terminal. The terminal executes the code "display_manual(result)" to display the contents of the related manual to the user.

[0866] An example prompt might be, "What is the procedure for handling a damaged product?" This process allows users to quickly find how to handle a specific complaint and follow the procedure.

[0867] As a concrete example, when a new employee responds to a complaint that "the product arrived damaged," the user first inputs the problem details into the UI, searches for it, and then follows the procedure based on the manual that is displayed. This allows complaints to be handled quickly and in a consistent manner, which is expected to improve customer satisfaction.

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

[0869] Step 1:

[0870] Data collection

[0871] The server connects to the company's database and retrieves historical customer service data.

[0872] Input: Your company's database connection information and query (e.g., "SELECT FROM cs_responses WHERE date > '2022-01-01'").

[0873] Output: The retrieved customer service data.

[0874] How it works: The server executes an SQL query to extract data from the database for a specified period of time, which is then loaded into memory for further processing.

[0875] Step 2:

[0876] Uploading additional data

[0877] The user (administrator) uploads new data to the system.

[0878] Input: New data file (e.g. "new_cs_responses.csv" in CSV format).

[0879] Output: The new data uploaded.

[0880] How it works: A user adds new data to the system by executing the command "upload_file('new_cs_responses.csv')" through the system's UI. Once the file is uploaded, the system validates the new data and integrates it into the existing dataset.

[0881] Step 3:

[0882] Data Cleansing

[0883] The server cleanses the collected or uploaded data.

[0884] Input: Data collected or uploaded.

[0885] Output: The cleansed data.

[0886] Operation: The server executes the code "data = pd.read_csv('new_cs_responses.csv')" to read the data, executes "data.dropna(inplace=True)" to remove missing data, formats the data, and proceeds to the next step.

[0887] Step 4:

[0888] Data training

[0889] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data.

[0890] Input: Cleansed data.

[0891] Output: A trained AI model.

[0892] How it works: The server uses a machine learning library (e.g., TensorFlow, PyTorch) to run "model.fit(data)" to train the data. Once training is complete, it saves the model with "model.save('cs_model.h5')". This allows the AI ​​model to learn useful patterns and keywords from past claim data.

[0893] Step 5:

[0894] Keyword and pattern extraction

[0895] The server uses a trained AI model to extract keywords and patterns relevant to a specific scenario.

[0896] Input: Cleansed data and a trained AI model.

[0897] Output: Extracted keywords and patterns.

[0898] How it works: The server runs the code "keywords = model.extract_keywords(data)" to extract important keywords and patterns from the data that are relevant to the specific scenario. These results are used in the next manual generation step.

[0899] Step 6:

[0900] Manual creation

[0901] Based on the extracted keywords and patterns, the server automatically generates a complaint handling manual using a generative AI model.

[0902] Input: Extracted keywords and patterns.

[0903] Output: Automatically generated complaint handling manual.

[0904] Operation: The server executes the code "manual_text = gpt.generate_manual(keywords)" to generate a complaint handling manual. The generated manual includes specific response procedures and important points to note.

[0905] Step 7:

[0906] Saving the manual

[0907] The server stores the generated complaint handling manual in a database or storage.

[0908] Input: Generated complaint handling manual.

[0909] Output: Manuals stored in a database or storage.

[0910] What happens: The server runs the code "save_manual_db('manual_2023_01', manual_text)" to save the manual to the database, laying the groundwork for later retrieval and display.

[0911] Step 8:

[0912] Search for manuals

[0913] When a user (new employee) wants to know how to handle a specific complaint, he or she enters search keywords through the UI.

[0914] Input: Search keywords (e.g. "The product arrived damaged").

[0915] Output: Related complaint handling manual.

[0916] How it works: A user enters a search query via the UI: "search_manual('The product arrived damaged')". The server receives the request and searches the database for the corresponding manual.

[0917] Step 9:

[0918] View the manual

[0919] The terminal sends a request to the server to retrieve and display the relevant manual.

[0920] Input: Search results received from the server.

[0921] Output: Complaint handling manual displayed on the terminal.

[0922] Operation: The server executes the query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" to retrieve the relevant manual. The terminal executes the code "display_manual(result)" to display the contents of the relevant manual to the user.

[0923] (Application example 1)

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

[0925] While automated production lines in modern factories have significantly improved efficiency, they can also have a negative impact on productivity if unexpected errors or complaints are not dealt with promptly. Furthermore, it is difficult for new staff to deal with these issues quickly and accurately, leading to the risk of delayed responses or inappropriate handling. This invention aims to respond quickly and effectively to errors and complaints that occur on production lines, reducing the burden on staff while maintaining production efficiency.

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

[0927] In this invention, the server includes means for collecting past customer service data, means for using generative artificial intelligence to learn the collected customer service data, means for automatically generating a complaint handling manual based on the learning results, means for saving the generated complaint handling manual, means for searching and displaying the generated complaint handling manual via a user interface, and means for generating a manual for resolving errors and complaints that occur in the automation system in the factory. This enables a quick and unified response to errors and complaints that occur in the factory.

[0928] "Historical customer service data" refers to data that a company collects and stores, such as information about customer service inquiries, complaints, feedback, and responses to such inquiries and complaints.

[0929] "Means of collection" refers to the process or mechanism by which the required customer service data is obtained from a company's database.

[0930] "Generative artificial intelligence" refers to AI systems that have the ability to analyze collected data, learn, and generate new information and answers.

[0931] A "complaint handling manual" is a document that lists specific procedures and points to note when dealing with complaints and inquiries from customers.

[0932] "Means for storage" refers to a system for properly storing the generated complaint handling manual in a database or storage for a certain period of time.

[0933] "User interface" refers to the software and hardware configuration that allows a user to interact with a system, and specifically includes a screen, input device, and the like.

[0934] "Means for searching and displaying" refers to a function for searching the complaint handling manual stored in the database as needed and visually displaying the results to the user.

[0935] "Factory automation system" refers to an integrated system of hardware and software for automatically executing manufacturing processes.

[0936] "Means for generating manuals for resolving errors and complaints" refers to a mechanism for automatically creating resolution procedures based on past data for problems that occur in automated systems within a factory.

[0937] As an embodiment of the present invention, a specific system implementation for dealing with errors and complaints in an automation system within a factory will be described below.

[0938] The system includes a data collection module for collecting past customer service data, a data processing module for cleansing and formatting the collected data, a manual generation module for automatically generating complaint handling manuals using generative artificial intelligence, a UI module for searching and displaying saved manuals via a user interface, and a means for quickly responding to errors and complaints that occur in the automation systems within the factory.

[0939] The server first collects past customer service data from the company's database. Specifically, it executes SQL queries to extract the necessary data from the database. The range and format of data to be collected are set by default. The server also provides a means for users to upload new data, ensuring that the system is always running with the latest data.

[0940] The collected data is then cleansed and formatted by a data processing module, which uses Python and Pandas to remove missing values ​​and standardize the data format, allowing the generative artificial intelligence to learn efficiently.

[0941] After the data is prepared, the server uses generative AI (for example, GPT-3 or TensorFlow) to automatically generate a complaint handling manual from the data. The generative AI learns from the data and generates a new manual based on past error resolution methods and complaint handling procedures.

[0942] The generated complaint handling manual is stored in server storage, which provides the foundation for later retrieval and display. A user interface (e.g., a web interface using Flask) is provided, through which users can search for response procedures based on specific errors or complaints.

[0943] As an actual usage example, consider the case where a robot in a factory stops working. In this case, the user enters a complaint, such as "The robot arm has stopped," into the interface and searches. The server searches the database for the relevant complaint handling manual and displays the generated procedure on the user's device. This allows the user to solve the problem quickly and accurately.

[0944] An example of an actual prompt is as follows:

[0945] text

[0946] Generate a complaint handling manual: The robot arm has stopped

[0947] In this way, the present invention is a system that enables a quick and unified response to errors and complaints that occur in the automation system within a factory, maintaining production efficiency while reducing the burden on staff.

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

[0949] Step 1: Data collection

[0950] The server collects historical customer service data from the company's database. It uses SQL queries to select data that matches certain criteria. For example, it executes a query like "SELECT FROM cs_responses WHERE date > '2022-01-01'." The input is the customer service data stored in the database, and the output is a list of data that matches the query. Users can also upload new data; in this case, the additional data is uploaded to the server in CSV format. The server then merges this new data with the existing data.

[0951] Step 2: Cleanse and shape the data

[0952] The server cleanses and formats the collected data using Python and the Pandas library. This involves removing missing values ​​and standardizing the data format. For example, "data.dropna(inplace=True)" is used to remove missing values, and then the data is formatted. The input to this step is the collected customer service data, and the output is the cleansed and formatted data.

[0953] Step 3: Train the data

[0954] The server inputs the cleansed data into a generative AI model for learning. The generative AI model used is TensorFlow, which learns patterns and important keywords from the data. Specifically, learning proceeds using "model.fit(data)", and then the model is saved using "model.save('cs_model.h5')". The input is the cleansed and formatted data, and the output is the trained AI model.

[0955] Step 4: Extracting keywords and patterns

[0956] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. Specifically, it extracts frequently occurring keywords using the formula "keywords = model.extract_keywords(data)". The input for this step is the trained AI model and newly provided scenario data, and the output is specific keywords and patterns.

[0957] Step 5: Automatic generation of manuals

[0958] The server automatically generates a complaint handling manual using a generative AI model based on the extracted keywords and patterns. In this case, it is common to use GPT-3 as the generative AI model. Specifically, the manual is generated using "manual_text = gpt.generate_manual(keywords)". The input is specific keywords and patterns, and the output is the generated complaint handling manual.

[0959] Step 6: Save the manual

[0960] The server saves the generated complaint handling manual in a database or storage. For example, it is saved as "save_manual_db('manual_2023_01', manual_text)". The input of this step is the generated manual, and the output is the manual saved in the database.

[0961] Step 7: Search and view the documentation

[0962] When a user wants to know how to handle a particular complaint, they enter relevant keywords through the user interface. The server searches the database for relevant manuals based on those keywords and displays them on the user's terminal. For example, if a user searches for "search_manual('The robot arm has stopped')", the server searches as "SELECT FROM manuals WHERE keywords LIKE '%robot arm%'" and returns the results to the user's terminal, which displays them as "display_manual(result)". The input to this step is the keyword entered by the user, and the output is the relevant manual displayed on the user's terminal.

[0963] Through these steps, this system enables a quick and unified response to errors and complaints that occur in the automation systems within a factory.

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

[0965] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). Furthermore, this system incorporates an emotion engine that recognizes user emotions, enabling the quality of complaint handling to be improved based on emotions. This system includes a data collection module, a data processing module, a manual generation module, an emotion engine module, and a user interface (UI) module.

[0966] Data Collection Module

[0967] Data collection

[0968] The server collects historical customer service data from the company's database by issuing an SQL query to the database, such as "SELECT FROM cs_responses WHERE date > '2022-01-01'".

[0969] Uploading additional data

[0970] A user (administrator) uploads new complaint response data to the system. The uploaded data is provided in a CSV file format, and the user adds the file to the system using the command "upload_file('new_cs_responses.csv')".

[0971] Data Processing Module

[0972] Data Cleansing

[0973] The server cleanses the collected or uploaded data. This includes removing missing values ​​and formatting the data. For example, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[0974] Data training

[0975] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process is done using machine learning libraries (e.g., TensorFlow, PyTorch). For example, the learning model is built using "model.fit(data)" or "model.save('cs_model.h5')".

[0976] Emotion Engine Module

[0977] Emotion recognition

[0978] The server uses an emotion engine to extract emotions from the user's input voice or text. The emotion engine uses natural language processing and speech analysis technologies to recognize emotional states such as anger, sadness, and joy.

[0979] For example, for voice input, emotions are analyzed using "audio_emotion = emotion_engine.analyze_audio(user_input)", and for text input, emotions are analyzed using "text_emotion = emotion_engine.analyze_text(user_input)".

[0980] Manual Generation Module

[0981] Keyword and pattern extraction

[0982] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. For example, the AI ​​model can be used to extract frequently occurring keywords using the format "keywords = model.extract_keywords(data)".

[0983] Manual creation

[0984] The server uses a generative AI model to automatically generate a complaint handling manual based on the extracted information. The generated manual includes specific response procedures and important points to note. The content and tone of the manual are also adjusted based on the recognized emotions.

[0985] For example, if the user is feeling angry, a particularly polite and careful response procedure can be incorporated. The manual is generated using the operation "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)".

[0986] Saving the manual

[0987] The server saves the generated manual in a database or storage. This saved manual serves as the basis for later searching and display. For example, it is saved in the form of "save_manual_db('manual_2023_01', manual_text)".

[0988] User Interface Module

[0989] Search for manuals

[0990] A user (new employee) searches for a specific complaint handling method through the user interface. For example, the user searches the system using the form "search_manual('The product arrived damaged')".

[0991] View the manual

[0992] The terminal sends a request to the server to retrieve and display the relevant manual. The server executes the SQL query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" to search for the relevant manual and returns the results to the terminal. The result is displayed on the terminal as "display_manual(result)".

[0993] Specific examples

[0994] For example, when a new employee responds to a complaint that "the product arrived damaged," the process would be as follows:

[0995] 1. A user (new employee) accepts a complaint and searches for the problem using the user interface.

[0996] 2. The server extracts appropriate keywords based on past data and generates a corresponding manual based on them.

[0997] 3. The emotion engine recognizes the user's (customer's) emotions and reflects them in the manual. For example, if a customer is angry, a particularly polite and prompt response procedure is required.

[0998] 4. The terminal displays the generated manual, and the user refers to it and takes appropriate action.

[0999] In this way, complaints can be dealt with promptly and appropriately, leading to improved customer satisfaction.

[1000] The processing flow will be explained below.

[1001] Step 1:

[1002] The server collects past customer service data from the company's database. Specifically, the server issues the SQL query "SELECT FROM cs_responses WHERE date > '2022-01-01'" to extract the target data from the database.

[1003] Step 2:

[1004] The user (administrator) uploads new complaint response data to the system. To upload, use the command "upload_file('new_cs_responses.csv')" to add data in CSV file format.

[1005] Step 3:

[1006] The server cleanses the uploaded data. It uses Python or similar tools to remove missing values ​​and format the data. For example, it uses operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[1007] Step 4:

[1008] The server inputs the cleansed data into a generative AI model, and uses machine learning libraries (e.g., TensorFlow, PyTorch) to learn patterns and important keywords from the data. Specifically, the learning model is constructed using commands such as "model.fit(data)" and "model.save('cs_model.h5')."

[1009] Step 5:

[1010] The server uses the emotion engine to extract emotions from the user's input voice or text. The emotion engine recognizes the user's emotional state using natural language processing and voice analysis technology. Specifically, for voice input, it performs the operation "audio_emotion = emotion_engine.analyze_audio(user_input)", and for text input, it performs the operation "text_emotion = emotion_engine.analyze_text(user_input)".

[1011] Step 6:

[1012] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. For example, it obtains frequently occurring keywords using the format "keywords = model.extract_keywords(data)".

[1013] Step 7:

[1014] The server uses a generative AI model to automatically generate a complaint handling manual based on the extracted keywords and the emotions recognized by the emotion engine. For example, if the user is feeling angry, a manual is created that includes polite and careful response procedures. The manual is generated using the operation "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)".

[1015] Step 8:

[1016] The server saves the generated manual to a database or storage. This is done in the form of "save_manual_db('manual_2023_01', manual_text)".

[1017] Step 9:

[1018] A user (new employee) searches for a specific complaint handling method through the user interface. For example, they search the system using the form "search_manual('The product arrived damaged')".

[1019] Step 10:

[1020] The terminal sends a request to the server to retrieve and display the relevant manual. The server executes the SQL query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" and returns the results to the terminal. The terminal displays the manual in the form of "display_manual(result)".

[1021] Step 11:

[1022] The user (new employee) refers to the displayed manual and follows specific procedures for handling complaints. For example, in response to a complaint that a product was delivered damaged, the user takes a photo, goes through the return procedure, and arranges for a replacement.

[1023] Example 2

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

[1025] In conventional complaint handling systems, it was difficult to efficiently utilize past customer service data and quickly and appropriately generate customer handling manuals. Furthermore, because handling procedures were determined without taking into account the customer's feelings, it was difficult to improve customer satisfaction. The present invention aims to solve these problems and provide a new system for improving the quality of customer handling.

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

[1027] In this invention, the server includes means for collecting past customer service data, means for shaping and cleansing the collected customer service data, means for learning data using generative artificial intelligence, means for automatically generating a complaint handling manual based on the learning results, means for saving the generated complaint handling manual, means for searching and displaying the generated complaint handling manual via a user interface, and means for recognizing user emotions and adjusting the content of the complaint handling manual based on the recognition results. This makes it possible to efficiently utilize past data and quickly respond appropriately to customer emotions.

[1028] "Past customer service data" refers to historical information such as inquiries, complaints, and response history received by a company from customers.

[1029] "Formatting and cleansing" refers to preprocessing work to improve data quality, such as removing missing values ​​and standardizing the format of data.

[1030] "Generative AI" refers to AI technology that can extract patterns and keywords from data and generate new sentences and content.

[1031] A "complaint handling manual" refers to a guideline or procedure manual that shows the steps that should be taken to respond to customer complaints.

[1032] "Storage" refers to the process of storing the generated complaint handling manual in a database or storage so that it can be reused later.

[1033] The term "user interface" refers to the parts that are directly operated by the user, such as the screen and input method that allow the user to interact with the system.

[1034] "Search and display" refers to the process of locating and finding specific information from a database and presenting the results in a visible form to the user.

[1035] "Emotion recognition" refers to the technology of analyzing and identifying a user's emotional state from their input voice or text.

[1036] "Adjusting the content" refers to the process of changing the content and tone of the complaint handling manual in response to perceived emotions to ensure an appropriate response.

[1037] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). The system includes a data collection module, a data processing module, a manual generation module, an emotion engine module, and a user interface (UI) module.

[1038] Data Collection Module

[1039] The server issues an SQL query to the company's database to collect past customer service data. Specifically, the query format is "SELECT FROM cs_responses WHERE date > '2022-01-01'". Furthermore, the user (administrator) uploads new complaint response data to the system in CSV file format. Specifically, the upload method uses the command "upload_file('new_cs_responses.csv')".

[1040] Data Processing Module

[1041] The server cleanses the collected or uploaded data. Data cleansing includes removing missing values ​​and formatting the data. Specific examples of operations include "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)." The server then inputs the cleansed data into a generative AI model to learn patterns and important keywords from the data. This process uses a machine learning library (e.g., TensorFlow, PyTorch) and executes operations such as "model.fit(data)" and "model.save('cs_model.h5')."

[1042] Emotion Engine Module

[1043] The server uses an emotion engine to extract emotions from the user's input voice or text. The emotion engine uses natural language processing technology and voice analysis technology. Specific examples of operations include "audio_emotion = emotion_engine.analyze_audio(user_input)" for voice input and "text_emotion = emotion_engine.analyze_text(user_input)" for text input.

[1044] Manual Generation Module

[1045] The server uses a trained AI model to extract keywords and patterns related to a specific scenario. An example is "keywords = model.extract_keywords(data)". The server then uses a generative AI model based on the extracted information to automatically generate a complaint handling manual. The generated manual includes specific response procedures and points to note, and the content and tone are adjusted based on the recognized emotions. For example, a manual is generated using the operation "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)". The server then saves the generated manual in a database or storage. An example is "save_manual_db('manual_2023_01', manual_text)".

[1046] User Interface Module

[1047] A user (new employee) searches for a specific complaint handling method via the user interface. An example of a specific prompt sentence is "search_manual('The product arrived damaged')". The terminal then sends a request to the server to retrieve and display the relevant manual. The server executes the query "SELECT FROM manuals WHERE keywords LIKE '%The product arrived damaged%'" and returns the results to the terminal. The results are displayed on the terminal in the form of "display_manual(result)".

[1048] Specific examples

[1049] For example, if a new employee is responding to a complaint that "the product arrived damaged," the user (new employee) accepts the complaint and uses the user interface to search for the problem. They enter the prompt "search_manual('The product arrived damaged')." The server extracts appropriate keywords from past data and generates a response manual based on those keywords. Furthermore, an emotion engine recognizes the user's (customer's) emotions and reflects them in the manual content. For example, if the customer is angry, a particularly polite and prompt response procedure is required. The terminal displays the generated manual, and the user refers to it to respond. This process enables a quick and accurate response to the complaint, leading to improved customer satisfaction.

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

[1051] Step 1:

[1052] The server issues an SQL query to the company's database to collect historical customer service data. Specifically, it executes the query "SELECT FROM cs_responses WHERE date > '2022-01-01'". This operation pulls historical customer service data into the server. The input is the database query result, and the output is the collected customer service data.

[1053] Step 2:

[1054] The user (administrator) uploads new complaint response data to the system in CSV file format. The specific upload method is to use the command "upload_file('new_cs_responses.csv')". This operation adds the new complaint response data to the system. The input is the CSV file, and the output is the new data saved in the system.

[1055] Step 3:

[1056] The server cleanses the collected or uploaded data. Data cleansing includes removing missing values ​​and formatting the data. Specific examples of operations include "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)". This operation results in formatted data with no missing values. The input is the collected data and uploaded data, and the output is the cleansed data.

[1057] Step 4:

[1058] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process uses machine learning libraries (e.g., TensorFlow, PyTorch). Specific examples of operations include "model.fit(data)" and "model.save('cs_model.h5')." This operation results in a trained AI model. The input is the cleansed data, and the output is the trained AI model.

[1059] Step 5:

[1060] The server uses an emotion engine to extract emotions from the user's input voice or text. The emotion engine uses natural language processing technology and voice analysis technology. Specific examples of operations include "audio_emotion = emotion_engine.analyze_audio(user_input)" for voice input and "text_emotion = emotion_engine.analyze_text(user_input)" for text input. This operation yields the extracted emotion data. The input is the user's voice or text, and the output is emotion data.

[1061] Step 6:

[1062] The server uses a trained AI model to extract keywords and patterns relevant to a specific scenario. An example is "keywords = model.extract_keywords(data)". This operation yields important keywords and patterns. The input is the trained AI model and cleansed data, and the output is the extracted keywords and patterns.

[1063] Step 7:

[1064] The server uses a generative AI model based on the extracted information to automatically generate a complaint handling manual. The generated manual includes specific response procedures and points to note, and the content and tone are adjusted based on the recognized emotions. An example of a specific operation is "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)". This operation results in a generated complaint handling manual. The input is the extracted keywords, patterns, and emotion data, and the output is the generated manual.

[1065] Step 8:

[1066] The server saves the generated manual in a database or storage. An example is "save_manual_db('manual_2023_01', manual_text)". This operation saves the complaint handling manual. The input is the generated manual, and the output is the manual stored in the database.

[1067] Step 9:

[1068] A user (new employee) searches for a specific complaint handling method through the user interface. An example of a specific prompt sentence is "search_manual('The product arrived damaged')". This operation searches for the relevant complaint handling manual. The input is the search query, and the output is the search results.

[1069] Step 10:

[1070] The terminal sends a request to the server, retrieves the relevant manual, and displays it. The server executes the query "SELECT FROM manuals WHERE keywords LIKE '%product is damaged%'" and returns the results to the terminal. The results are displayed on the terminal in the form of "display_manual(result)". This operation provides the user with the procedure to follow. The input is the search results, and the output is the displayed manual.

[1071] (Application example 2)

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

[1073] Conventional complaint handling systems have the problem of being difficult to recognize customer emotions and respond appropriately. Furthermore, generating response procedures is slow, which makes new employees feel uneasy about handling complaints, especially in physical stores, where speed is required. Furthermore, the lack of voice input, which requires manual input, reduces the efficiency and accuracy of responses.

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

[1075] In this invention, the server includes a means for collecting past customer service data, a means for using generative artificial intelligence to learn from the collected customer service data, a means for voice input of the complaint details, a means for analyzing the customer's emotional state during the complaint handling process, and a means for including optimal response procedures in a complaint handling manual based on the analysis results. This enables improved efficiency and accuracy in complaint handling. Furthermore, by recognizing customer emotions in real time and providing optimal response procedures accordingly, improved customer satisfaction can be expected.

[1076] "Past customer service data" refers to all past data related to the customer service provided by a company, including, for example, complaint details, response history, and customer feedback.

[1077] "Means of collection" refers to the technological methods or devices used to obtain historical customer service data from a company's database or other data storage.

[1078] "Generative artificial intelligence" refers to artificial intelligence that has the ability to generate new information or manuals based on existing data, and includes, for example, machine learning models and natural language generation models.

[1079] "Means of learning" refers to the processing technology that inputs collected data into generative artificial intelligence and allows it to recognize patterns and trends.

[1080] "Means for automatically generating complaint handling manuals" refers to technology that automatically creates response procedures and guidelines for specific scenarios based on learned data.

[1081] "Means for storage" refers to the technology used to store the generated complaint handling manual in a database or storage device.

[1082] "User Interface" means the interface that enables a user to interact with a system and enter, retrieve, and display information.

[1083] "Means for searching and displaying" refers to a technology for searching the generated complaint handling manual through a user interface and displaying the results to the user.

[1084] "Voice input means" refers to the technology used to convert speech into text and input it into the system.

[1085] "Means for analyzing the emotional state of customers" refers to technology for recognizing and analyzing customer emotions from the content of complaints and conversations.

[1086] "Means including optimal response procedures" refers to the technology of incorporating appropriate response procedures into a complaint handling manual based on the analysis results.

[1087] The system for implementing this invention is composed of the following main modules. These modules work together to improve the quality of complaint handling.

[1088] 1. Data Collection Module

[1089] The server collects historical customer service data from the company's database. Specifically, it uses SQL queries to extract relevant data and imports it into the system. Administrators can also upload new data, for example in CSV file format. This additional data is used in the data processing module, which is described later.

[1090] 2. Data Processing Module

[1091] The server cleanses the collected data, removing missing values, and performs other formatting operations. The cleansed data is then fed into a generative artificial intelligence (AI) model to learn patterns and important keywords. This training process uses machine learning libraries (such as TensorFlow and PyTorch).

[1092] 3. Emotion Engine Module

[1093] The server converts the speech to text using a speech recognition API (such as Google Cloud Speech-to-Text). The converted text is then fed into an emotion engine, which uses natural language processing and speech analysis techniques to recognize emotional states (e.g., anger or sadness). This emotion data is then used in the manual generation process described below.

[1094] 4. Manual Generation Module

[1095] The server uses a trained generative AI model (such as OpenAI's GPT-3) to automatically generate a response manual based on a complaint scenario. This response procedure is adjusted based on the extracted keywords and recognized emotions. Depending on the emotional state, a particularly polite and careful response procedure may be incorporated.

[1096] 5. User Interface Module

[1097] Users (such as new employees) can use a smartphone, smart glasses, or head-mounted display to voice-input the details of a complaint. The voice data is sent to the server, and an appropriate response manual is then generated through the above-mentioned module. This manual is displayed through the user interface, allowing the user to respond based on the contents in real time.

[1098] As a concrete example, consider a case where a new employee uses smart glasses to handle complaints.

[1099] 1. The store clerk (user) says, "The product arrived broken."

[1100] 2. The server converts the speech to text and analyzes the sentiment using an emotion engine.

[1101] 3. The emotion engine detects "anger" and uses a generative AI model to generate an appropriate response manual.

[1102] 4. Specific instructions for how to proceed will be displayed on the smart glasses, such as "We apologize. We will immediately process your product exchange."

[1103] Example prompt sentence:

[1104] Complaint: The product arrived broken.

[1105] Customer Emotion: Anger

[1106] Generate the corresponding manual:

[1107] In this way, complaints can be dealt with promptly and appropriately, leading to improved customer satisfaction.

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

[1109] Step 1:

[1110] Data collection

[1111] The server collects historical customer service data from the company's database. Specifically, the server issues an SQL query (e.g., "SELECT FROM cs_responses WHERE date > '2022-01-01'") to retrieve relevant data. This allows data such as complaint details and response history to be collected. The input is the SQL query, and the output is a set of customer service data.

[1112] Step 2:

[1113] Uploading additional data

[1114] A user (administrator) uploads new complaint response data to the system. The file is provided in CSV format and is added to the system using the command (e.g., "upload_file('new_cs_responses.csv')"). The input is the new complaint response data file, and the output is the new data added to the database in the system.

[1115] Step 3:

[1116] Data Cleansing

[1117] The server cleanses the collected or uploaded data. It removes missing values ​​and formats the data. Specifically, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)". The input is the collected data filter set, and the output is the cleansed dataset.

[1118] Step 4:

[1119] Data training

[1120] The server then inputs the cleansed data into a generative artificial intelligence (AI) model to learn patterns and important keywords from the data. This process uses machine learning libraries (e.g., TensorFlow, PyTorch) and specific operations such as "model.fit(data)" and "model.save('cs_model.h5')". The input is the cleansed data, and the output is a trained AI model.

[1121] Step 5:

[1122] Voice input

[1123] The user (store clerk) inputs the details of the complaint into a smartphone or smart glasses by voice. This voice data is sent to the server. The input is voice data, and the output is data converted from voice to text.

[1124] Step 6:

[1125] Emotion recognition

[1126] The server inputs the text data of the complaint content into the emotion engine and analyzes the customer's emotions. The emotion engine uses natural language processing and speech analysis technology to recognize emotional states (e.g., anger, sadness, joy, etc.). The input is the text data of the complaint content, and the output is the analyzed emotion data.

[1127] Step 7:

[1128] Manual Generation

[1129] The server uses a trained generative AI model to automatically generate a response manual based on a complaint scenario. Based on the complaint content and emotional data, it creates a prompt sentence and inputs it into the generative AI model. The generated manual includes specific response procedures such as, "We apologize. We will process the product exchange immediately." The input is the complaint content and emotional data, and the output is the generated response manual.

[1130] Step 8:

[1131] View the manual

[1132] The terminal (smartphone or smart glasses) receives the response manual generated from the server and displays it through the user interface. The user can then respond to the complaint quickly and accurately based on the displayed manual. The input is the generated response manual, and the output is the manual displayed to the user.

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

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

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

[1136] [Fourth embodiment]

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

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

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

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

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

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

[1143] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

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

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

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

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

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

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

[1150] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). This system includes a data collection module, a data processing module, a manual generation module, and a user interface (UI) module.

[1151] Data Collection Module

[1152] Data collection

[1153] The server collects historical customer service data from the company's database, including customer inquiries, complaints, feedback, and responses thereto.

[1154] For example, the server executes an SQL query to extract data in the form "SELECT FROM cs_responses WHERE date > '2022-01-01'".

[1155] Uploading additional data

[1156] A user (administrator) uploads new data to the system. This additional data is typically provided in a CSV file format.

[1157] For example, a user adds new data to the system using the command "upload_file('new_cs_responses.csv')".

[1158] Data Processing Module

[1159] Data Cleansing

[1160] The server cleanses the collected or uploaded data, which includes removing missing values ​​and formatting the data.

[1161] For example, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[1162] Data training

[1163] The server then feeds the cleansed data into a generative AI model that learns patterns and important keywords from the data. This process is done using machine learning libraries (e.g., TensorFlow, PyTorch).

[1164] For example, a learning model is constructed using the following commands: "model.fit(data)" and "model.save('cs_model.h5')".

[1165] Manual Generation Module

[1166] Keyword and pattern extraction

[1167] The server uses a trained AI model to extract keywords and patterns relevant to a specific scenario.

[1168] For example, use an AI model to extract frequently occurring keywords using the format "keywords = model.extract_keywords(data)".

[1169] Manual creation

[1170] The server uses a generative AI model to automatically generate a complaint handling manual based on the extracted information. The generated manual includes specific response procedures and important points to note.

[1171] For example, a manual can be generated using the operation "manual_text = gpt.generate_manual(keywords)".

[1172] Saving the manual

[1173] The server stores the generated manual in a database or storage, which serves as the basis for later retrieval and display.

[1174] For example, saving is done in the form "save_manual_db('manual_2023_01', manual_text)".

[1175] User Interface Module

[1176] Search for manuals

[1177] When a user (new employee) wants to know how to handle a specific complaint, he or she enters search keywords through the UI.

[1178] For example, a user searches the system using the following format: "search_manual('The product arrived damaged')".

[1179] View the manual

[1180] The terminal sends a request to the server to retrieve and display the relevant manual.

[1181] For example, the server searches for related manual entries and returns the results to the terminal as "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'". The results are displayed on the terminal as "display_manual(result)".

[1182] As a concrete example, when a new employee responds to a complaint that "the product arrived damaged," the user first searches for the problem in the UI. The server retrieves the relevant manual from the database and displays it on the terminal. The new employee can then refer to the displayed manual and handle the complaint by following specific procedures, such as taking a photo, completing the return procedure, and arranging for a replacement. In this way, complaints are handled quickly and in a unified manner, leading to improved customer satisfaction.

[1183] The processing flow will be explained below.

[1184] Step 1:

[1185] The server collects historical customer service data from the company's database by issuing an SQL query to the database, such as "SELECT FROM cs_responses WHERE date > '2022-01-01'".

[1186] Step 2:

[1187] A user (administrator) uploads new complaint response data to the system. The uploaded data is provided in a CSV file format, and the user adds the file to the system using the command "upload_file('new_cs_responses.csv')".

[1188] Step 3:

[1189] The server cleanses the uploaded data. This includes removing missing values ​​and formatting the data. For example, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[1190] Step 4:

[1191] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process is done using machine learning libraries (e.g., TensorFlow, PyTorch). For example, the learning model is built using "model.fit(data)" or "model.save('cs_model.h5')".

[1192] Step 5:

[1193] The server uses the trained AI model to extract keywords and patterns relevant to a specific scenario from historical customer service data. For example, the AI ​​model can be used to extract frequently occurring keywords using the formula "keywords = model.extract_keywords(data)".

[1194] Step 6:

[1195] The server automatically generates a complaint handling manual using a generative AI model based on the extracted keywords and patterns. The generated manual includes specific response procedures and important points to note. For example, a manual can be generated using the operation "manual_text = gpt.generate_manual(keywords)".

[1196] Step 7:

[1197] The server saves the generated manual in a database or storage. This saved manual serves as the basis for later searching and display. For example, it is saved in the form of "save_manual_db('manual_2023_01', manual_text)".

[1198] Step 8:

[1199] A user (new employee) searches for a specific complaint handling method through the user interface. For example, the user searches the system using the form "search_manual('The product arrived damaged')".

[1200] Step 9:

[1201] The terminal sends a request to the server to retrieve and display the relevant manual. The server executes the SQL query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" to search for the relevant manual and returns the results to the terminal. The result is displayed on the terminal as "display_manual(result)".

[1202] Step 10:

[1203] The user (new employee) refers to the displayed manual and follows specific complaint handling procedures. For example, in the case of a damaged product, the user can practice procedures such as "have a photo taken," "proceed with the return shipping," and "arrange for a replacement."

[1204] Example 1

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

[1206] Conventional complaint handling systems have had problems with insufficient use of past customer service data, resulting in a lack of quality and speed in responses. Furthermore, the creation of response manuals is often manual, resulting in inefficiency and a lack of consistency. The present invention aims to solve these problems by providing a system that automatically generates prompt and appropriate complaint handling manuals while effectively utilizing past data.

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

[1208] In this invention, the server includes means for collecting past customer service data, means for uploading the collected customer service data, means for cleansing the uploaded data, means for learning the cleansed data using generative artificial intelligence, means for extracting keywords and patterns related to a specific scenario based on the learning results, means for automatically generating a complaint handling manual based on the extracted information, means for saving the generated complaint handling manual, and means for searching for and displaying the generated complaint handling manual via a user interface. This enables the effective use of past data to automatically generate a complaint handling manual that is quick and consistent.

[1209] "Past customer service data" refers to data that includes information about customer service, such as inquiries, complaints, feedback, and responses thereto from past customers.

[1210] "Means of collection" refers to the processes and tools used to obtain historical customer service data from a company's database.

[1211] "Means of uploading" refers to the operations or interface that a user (administrator) uses to add new data to the system.

[1212] "Cleansing measures" refers to processes used to remove missing values ​​or format collected or uploaded data.

[1213] "Generative AI" refers to an AI technology that can learn patterns and important keywords from input data and generate new information based on that.

[1214] "Means of learning" refers to the process by which generative AI uses cleansed data to learn patterns and important keywords from the data.

[1215] "Means for extracting keywords and patterns relevant to a specific scenario" refers to the process of using the learning results to extract important keywords and patterns necessary to respond to a specific situation.

[1216] A "complaint handling manual" refers to a guideline that lists procedures and precautions for handling customer complaints.

[1217] "Means for automatic generation" refers to the process of automatically creating a complaint handling manual based on the extracted information using generative artificial intelligence.

[1218] "Means for storage" refers to the processes and tools for storing the generated complaint handling manual in a database or other storage.

[1219] "User interface" refers to the screen and input means through which a user interacts with a system.

[1220] "Means for searching and displaying" refers to the process or tool that allows a user to find a specific complaint handling manual and display it on a terminal.

[1221] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). The system includes a data collection module, a data processing module, a manual generation module, and a user interface (UI) module.

[1222] Data Collection Module

[1223] The server connects to the company's database to collect historical customer service data. This data can be collected using SQL queries. For example, the query "SELECT FROM cs_responses WHERE date > '2022-01-01'" is executed to retrieve the data. The collected data is stored in the system's memory.

[1224] Uploading additional data

[1225] When a user (administrator) uploads new data to the system, they use a file, such as a CSV file. The upload operation is performed using the system's UI, and data is added using a command such as "upload_file('new_cs_responses.csv')". Once the upload is complete, the system validates the new data and merges it with the existing data.

[1226] Data Processing Module

[1227] The server cleanses the collected or uploaded data. This process includes removing missing values ​​and formatting the data. Specifically, it reads the data with "data = pd.read_csv('new_cs_responses.csv')" and removes missing data with "data.dropna(inplace=True)". The cleansed data is saved for the next learning step.

[1228] Data training

[1229] The server inputs the cleansed data into a generative AI model to learn patterns and important keywords. This uses machine learning libraries (e.g., TensorFlow, PyTorch). For example, run "model.fit(data)" to train the model, and then run "model.save('cs_model.h5')" to save the trained model. This process enables the AI ​​model to extract useful patterns and keywords from past claim data.

[1230] Manual Generation Module

[1231] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. For example, it runs the code "keywords = model.extract_keywords(data)" to extract frequently occurring keywords. Next, a complaint handling manual is automatically generated by the generative AI model based on the extracted keywords. Specifically, the manual is generated using the operation "manual_text = gpt.generate_manual(keywords)". This manual includes specific procedures and reference information for handling complaints.

[1232] Saving the manual

[1233] The server saves the generated manual in a database or storage. For example, it executes the code "save_manual_db('manual_2023_01', manual_text)" to save the manual. The saved manual is structured so that it can be easily searched and displayed later.

[1234] User Interface Module

[1235] When a user (new employee) wants to know how to handle a specific complaint, they enter search keywords through the UI. For example, they enter the search query "search_manual('The product arrived damaged')". The server receives this request and searches the database for relevant manuals.

[1236] The terminal sends a request to the server to retrieve and display the related manual. For example, the server executes the query "SELECT FROM manuals WHERE keywords LIKE '%product is damaged%'" and sends the result to the terminal. The terminal executes the code "display_manual(result)" to display the contents of the related manual to the user.

[1237] An example prompt might be, "What is the procedure for handling a damaged product?" This process allows users to quickly find how to handle a specific complaint and follow the procedure.

[1238] As a concrete example, when a new employee responds to a complaint that "the product arrived damaged," the user first inputs the problem details into the UI, searches for it, and then follows the procedure based on the manual that is displayed. This allows complaints to be handled quickly and in a consistent manner, which is expected to improve customer satisfaction.

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

[1240] Step 1:

[1241] Data collection

[1242] The server connects to the company's database and retrieves historical customer service data.

[1243] Input: Your company's database connection information and query (e.g., "SELECT FROM cs_responses WHERE date > '2022-01-01'").

[1244] Output: The retrieved customer service data.

[1245] How it works: The server executes an SQL query to extract data from the database for a specified period of time, which is then loaded into memory for further processing.

[1246] Step 2:

[1247] Uploading additional data

[1248] The user (administrator) uploads new data to the system.

[1249] Input: New data file (e.g. "new_cs_responses.csv" in CSV format).

[1250] Output: The new data uploaded.

[1251] How it works: A user adds new data to the system by executing the command "upload_file('new_cs_responses.csv')" through the system's UI. Once the file is uploaded, the system validates the new data and integrates it into the existing dataset.

[1252] Step 3:

[1253] Data Cleansing

[1254] The server cleanses the collected or uploaded data.

[1255] Input: Data collected or uploaded.

[1256] Output: The cleansed data.

[1257] Operation: The server executes the code "data = pd.read_csv('new_cs_responses.csv')" to read the data, executes "data.dropna(inplace=True)" to remove missing data, formats the data, and proceeds to the next step.

[1258] Step 4:

[1259] Data training

[1260] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data.

[1261] Input: Cleansed data.

[1262] Output: A trained AI model.

[1263] How it works: The server uses a machine learning library (e.g., TensorFlow, PyTorch) to run "model.fit(data)" to train the data. Once training is complete, it saves the model with "model.save('cs_model.h5')". This allows the AI ​​model to learn useful patterns and keywords from past claim data.

[1264] Step 5:

[1265] Keyword and pattern extraction

[1266] The server uses a trained AI model to extract keywords and patterns relevant to a specific scenario.

[1267] Input: Cleansed data and a trained AI model.

[1268] Output: Extracted keywords and patterns.

[1269] How it works: The server runs the code "keywords = model.extract_keywords(data)" to extract important keywords and patterns from the data that are relevant to the specific scenario. These results are used in the next manual generation step.

[1270] Step 6:

[1271] Manual creation

[1272] Based on the extracted keywords and patterns, the server automatically generates a complaint handling manual using a generative AI model.

[1273] Input: Extracted keywords and patterns.

[1274] Output: Automatically generated complaint handling manual.

[1275] Operation: The server executes the code "manual_text = gpt.generate_manual(keywords)" to generate a complaint handling manual. The generated manual includes specific response procedures and important points to note.

[1276] Step 7:

[1277] Saving the manual

[1278] The server stores the generated complaint handling manual in a database or storage.

[1279] Input: Generated complaint handling manual.

[1280] Output: Manuals stored in a database or storage.

[1281] What happens: The server runs the code "save_manual_db('manual_2023_01', manual_text)" to save the manual to the database, laying the groundwork for later retrieval and display.

[1282] Step 8:

[1283] Search for manuals

[1284] When a user (new employee) wants to know how to handle a specific complaint, he or she enters search keywords through the UI.

[1285] Input: Search keywords (e.g. "The product arrived damaged").

[1286] Output: Related complaint handling manual.

[1287] How it works: A user enters a search query via the UI: "search_manual('The product arrived damaged')". The server receives the request and searches the database for the corresponding manual.

[1288] Step 9:

[1289] View the manual

[1290] The terminal sends a request to the server to retrieve and display the relevant manual.

[1291] Input: Search results received from the server.

[1292] Output: Complaint handling manual displayed on the terminal.

[1293] Operation: The server executes the query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" to retrieve the relevant manual. The terminal executes the code "display_manual(result)" to display the contents of the relevant manual to the user.

[1294] (Application example 1)

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

[1296] While automated production lines in modern factories have significantly improved efficiency, they can also have a negative impact on productivity if unexpected errors or complaints are not dealt with promptly. Furthermore, it is difficult for new staff to deal with these issues quickly and accurately, leading to the risk of delayed responses or inappropriate handling. This invention aims to respond quickly and effectively to errors and complaints that occur on production lines, reducing the burden on staff while maintaining production efficiency.

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

[1298] In this invention, the server includes means for collecting past customer service data, means for using generative artificial intelligence to learn the collected customer service data, means for automatically generating a complaint handling manual based on the learning results, means for saving the generated complaint handling manual, means for searching and displaying the generated complaint handling manual via a user interface, and means for generating a manual for resolving errors and complaints that occur in the automation system in the factory. This enables a quick and unified response to errors and complaints that occur in the factory.

[1299] "Historical customer service data" refers to data that a company collects and stores, such as information about customer service inquiries, complaints, feedback, and responses to such inquiries and complaints.

[1300] "Means of collection" refers to the process or mechanism by which the required customer service data is obtained from a company's database.

[1301] "Generative artificial intelligence" refers to AI systems that have the ability to analyze collected data, learn, and generate new information and answers.

[1302] A "complaint handling manual" is a document that lists specific procedures and points to note when dealing with complaints and inquiries from customers.

[1303] "Means for storage" refers to a system for properly storing the generated complaint handling manual in a database or storage for a certain period of time.

[1304] "User interface" refers to the software and hardware configuration that allows a user to interact with a system, and specifically includes a screen, input device, and the like.

[1305] "Means for searching and displaying" refers to a function for searching the complaint handling manual stored in the database as needed and visually displaying the results to the user.

[1306] "Factory automation system" refers to an integrated system of hardware and software for automatically executing manufacturing processes.

[1307] "Means for generating manuals for resolving errors and complaints" refers to a mechanism for automatically creating resolution procedures based on past data for problems that occur in automated systems within a factory.

[1308] As an embodiment of the present invention, a specific system implementation for dealing with errors and complaints in an automation system within a factory will be described below.

[1309] The system includes a data collection module for collecting past customer service data, a data processing module for cleansing and formatting the collected data, a manual generation module for automatically generating complaint handling manuals using generative artificial intelligence, a UI module for searching and displaying saved manuals via a user interface, and a means for quickly responding to errors and complaints that occur in the automation systems within the factory.

[1310] The server first collects past customer service data from the company's database. Specifically, it executes SQL queries to extract the necessary data from the database. The range and format of data to be collected are set by default. The server also provides a means for users to upload new data, ensuring that the system is always running with the latest data.

[1311] The collected data is then cleansed and formatted by a data processing module, which uses Python and Pandas to remove missing values ​​and standardize the data format, allowing the generative artificial intelligence to learn efficiently.

[1312] After the data is prepared, the server uses generative AI (for example, GPT-3 or TensorFlow) to automatically generate a complaint handling manual from the data. The generative AI learns from the data and generates a new manual based on past error resolution methods and complaint handling procedures.

[1313] The generated complaint handling manual is stored in server storage, which provides the foundation for later retrieval and display. A user interface (e.g., a web interface using Flask) is provided, through which users can search for response procedures based on specific errors or complaints.

[1314] As an actual usage example, consider the case where a robot in a factory stops working. In this case, the user enters a complaint, such as "The robot arm has stopped," into the interface and searches. The server searches the database for the relevant complaint handling manual and displays the generated procedure on the user's device. This allows the user to solve the problem quickly and accurately.

[1315] An example of an actual prompt is as follows:

[1316] text

[1317] Generate a complaint handling manual: The robot arm has stopped

[1318] In this way, the present invention is a system that enables a quick and unified response to errors and complaints that occur in the automation system within a factory, maintaining production efficiency while reducing the burden on staff.

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

[1320] Step 1: Data collection

[1321] The server collects historical customer service data from the company's database. It uses SQL queries to select data that matches certain criteria. For example, it executes a query like "SELECT FROM cs_responses WHERE date > '2022-01-01'." The input is the customer service data stored in the database, and the output is a list of data that matches the query. Users can also upload new data; in this case, the additional data is uploaded to the server in CSV format. The server then merges this new data with the existing data.

[1322] Step 2: Cleanse and shape the data

[1323] The server cleanses and formats the collected data using Python and the Pandas library. This involves removing missing values ​​and standardizing the data format. For example, "data.dropna(inplace=True)" is used to remove missing values, and then the data is formatted. The input to this step is the collected customer service data, and the output is the cleansed and formatted data.

[1324] Step 3: Train the data

[1325] The server inputs the cleansed data into a generative AI model for learning. The generative AI model used is TensorFlow, which learns patterns and important keywords from the data. Specifically, learning proceeds using "model.fit(data)", and then the model is saved using "model.save('cs_model.h5')". The input is the cleansed and formatted data, and the output is the trained AI model.

[1326] Step 4: Extracting keywords and patterns

[1327] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. Specifically, it extracts frequently occurring keywords using the formula "keywords = model.extract_keywords(data)". The input for this step is the trained AI model and newly provided scenario data, and the output is specific keywords and patterns.

[1328] Step 5: Automatic generation of manuals

[1329] The server automatically generates a complaint handling manual using a generative AI model based on the extracted keywords and patterns. In this case, it is common to use GPT-3 as the generative AI model. Specifically, the manual is generated using "manual_text = gpt.generate_manual(keywords)". The input is specific keywords and patterns, and the output is the generated complaint handling manual.

[1330] Step 6: Save the manual

[1331] The server saves the generated complaint handling manual in a database or storage. For example, it is saved as "save_manual_db('manual_2023_01', manual_text)". The input of this step is the generated manual, and the output is the manual saved in the database.

[1332] Step 7: Search and view the documentation

[1333] When a user wants to know how to handle a particular complaint, they enter relevant keywords through the user interface. The server searches the database for relevant manuals based on those keywords and displays them on the user's terminal. For example, if a user searches for "search_manual('The robot arm has stopped')", the server searches as "SELECT FROM manuals WHERE keywords LIKE '%robot arm%'" and returns the results to the user's terminal, which displays them as "display_manual(result)". The input to this step is the keyword entered by the user, and the output is the relevant manual displayed on the user's terminal.

[1334] Through these steps, this system enables a quick and unified response to errors and complaints that occur in the automation systems within a factory.

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

[1336] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). Furthermore, this system incorporates an emotion engine that recognizes user emotions, enabling the quality of complaint handling to be improved based on emotions. This system includes a data collection module, a data processing module, a manual generation module, an emotion engine module, and a user interface (UI) module.

[1337] Data Collection Module

[1338] Data collection

[1339] The server collects historical customer service data from the company's database by issuing an SQL query to the database, such as "SELECT FROM cs_responses WHERE date > '2022-01-01'".

[1340] Uploading additional data

[1341] A user (administrator) uploads new complaint response data to the system. The uploaded data is provided in a CSV file format, and the user adds the file to the system using the command "upload_file('new_cs_responses.csv')".

[1342] Data Processing Module

[1343] Data Cleansing

[1344] The server cleanses the collected or uploaded data. This includes removing missing values ​​and formatting the data. For example, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[1345] Data training

[1346] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process is done using machine learning libraries (e.g., TensorFlow, PyTorch). For example, the learning model is built using "model.fit(data)" or "model.save('cs_model.h5')".

[1347] Emotion Engine Module

[1348] Emotion recognition

[1349] The server uses an emotion engine to extract emotions from the user's input voice or text. The emotion engine uses natural language processing and speech analysis technologies to recognize emotional states such as anger, sadness, and joy.

[1350] For example, for voice input, emotions are analyzed using "audio_emotion = emotion_engine.analyze_audio(user_input)", and for text input, emotions are analyzed using "text_emotion = emotion_engine.analyze_text(user_input)".

[1351] Manual Generation Module

[1352] Keyword and pattern extraction

[1353] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. For example, the AI ​​model can be used to extract frequently occurring keywords using the format "keywords = model.extract_keywords(data)".

[1354] Manual creation

[1355] The server uses a generative AI model to automatically generate a complaint handling manual based on the extracted information. The generated manual includes specific response procedures and important points to note. The content and tone of the manual are also adjusted based on the recognized emotions.

[1356] For example, if the user is feeling angry, a particularly polite and careful response procedure can be incorporated. The manual is generated using the operation "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)".

[1357] Saving the manual

[1358] The server saves the generated manual in a database or storage. This saved manual serves as the basis for later searching and display. For example, it is saved in the form of "save_manual_db('manual_2023_01', manual_text)".

[1359] User Interface Module

[1360] Search for manuals

[1361] A user (new employee) searches for a specific complaint handling method through the user interface. For example, the user searches the system using the form "search_manual('The product arrived damaged')".

[1362] View the manual

[1363] The terminal sends a request to the server to retrieve and display the relevant manual. The server executes the SQL query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" to search for the relevant manual and returns the results to the terminal. The result is displayed on the terminal as "display_manual(result)".

[1364] Specific examples

[1365] For example, when a new employee responds to a complaint that "the product arrived damaged," the process would be as follows:

[1366] 1. A user (new employee) accepts a complaint and searches for the problem using the user interface.

[1367] 2. The server extracts appropriate keywords based on past data and generates a corresponding manual based on them.

[1368] 3. The emotion engine recognizes the user's (customer's) emotions and reflects them in the manual. For example, if a customer is angry, a particularly polite and prompt response procedure is required.

[1369] 4. The terminal displays the generated manual, and the user refers to it and takes appropriate action.

[1370] In this way, complaints can be dealt with promptly and appropriately, leading to improved customer satisfaction.

[1371] The processing flow will be explained below.

[1372] Step 1:

[1373] The server collects past customer service data from the company's database. Specifically, the server issues the SQL query "SELECT FROM cs_responses WHERE date > '2022-01-01'" to extract the target data from the database.

[1374] Step 2:

[1375] The user (administrator) uploads new complaint response data to the system. To upload, use the command "upload_file('new_cs_responses.csv')" to add data in CSV file format.

[1376] Step 3:

[1377] The server cleanses the uploaded data. It uses Python or similar tools to remove missing values ​​and format the data. For example, it uses operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)".

[1378] Step 4:

[1379] The server inputs the cleansed data into a generative AI model, and uses machine learning libraries (e.g., TensorFlow, PyTorch) to learn patterns and important keywords from the data. Specifically, the learning model is constructed using commands such as "model.fit(data)" and "model.save('cs_model.h5')."

[1380] Step 5:

[1381] The server uses the emotion engine to extract emotions from the user's input voice or text. The emotion engine recognizes the user's emotional state using natural language processing and voice analysis technology. Specifically, for voice input, it performs the operation "audio_emotion = emotion_engine.analyze_audio(user_input)", and for text input, it performs the operation "text_emotion = emotion_engine.analyze_text(user_input)".

[1382] Step 6:

[1383] The server uses the trained AI model to extract keywords and patterns related to a specific scenario. For example, it obtains frequently occurring keywords using the format "keywords = model.extract_keywords(data)".

[1384] Step 7:

[1385] The server uses a generative AI model to automatically generate a complaint handling manual based on the extracted keywords and the emotions recognized by the emotion engine. For example, if the user is feeling angry, a manual is created that includes polite and careful response procedures. The manual is generated using the operation "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)".

[1386] Step 8:

[1387] The server saves the generated manual to a database or storage. This is done in the form of "save_manual_db('manual_2023_01', manual_text)".

[1388] Step 9:

[1389] A user (new employee) searches for a specific complaint handling method through the user interface. For example, they search the system using the form "search_manual('The product arrived damaged')".

[1390] Step 10:

[1391] The terminal sends a request to the server to retrieve and display the relevant manual. The server executes the SQL query "SELECT FROM manuals WHERE keywords LIKE '%item is damaged%'" and returns the results to the terminal. The terminal displays the manual in the form of "display_manual(result)".

[1392] Step 11:

[1393] The user (new employee) refers to the displayed manual and follows specific procedures for handling complaints. For example, in response to a complaint that a product was delivered damaged, the user takes a photo, goes through the return procedure, and arranges for a replacement.

[1394] Example 2

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

[1396] In conventional complaint handling systems, it was difficult to efficiently utilize past customer service data and quickly and appropriately generate customer handling manuals. Furthermore, because handling procedures were determined without taking into account the customer's feelings, it was difficult to improve customer satisfaction. The present invention aims to solve these problems and provide a new system for improving the quality of customer handling.

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

[1398] In this invention, the server includes means for collecting past customer service data, means for shaping and cleansing the collected customer service data, means for learning data using generative artificial intelligence, means for automatically generating a complaint handling manual based on the learning results, means for saving the generated complaint handling manual, means for searching and displaying the generated complaint handling manual via a user interface, and means for recognizing user emotions and adjusting the content of the complaint handling manual based on the recognition results. This makes it possible to efficiently utilize past data and quickly respond appropriately to customer emotions.

[1399] "Past customer service data" refers to historical information such as inquiries, complaints, and response history received by a company from customers.

[1400] "Formatting and cleansing" refers to preprocessing work to improve data quality, such as removing missing values ​​and standardizing the format of data.

[1401] "Generative AI" refers to AI technology that can extract patterns and keywords from data and generate new sentences and content.

[1402] A "complaint handling manual" refers to a guideline or procedure manual that shows the steps that should be taken to respond to customer complaints.

[1403] "Storage" refers to the process of storing the generated complaint handling manual in a database or storage so that it can be reused later.

[1404] The term "user interface" refers to the parts that are directly operated by the user, such as the screen and input method that allow the user to interact with the system.

[1405] "Search and display" refers to the process of locating and finding specific information from a database and presenting the results in a visible form to the user.

[1406] "Emotion recognition" refers to the technology of analyzing and identifying a user's emotional state from their input voice or text.

[1407] "Adjusting the content" refers to the process of changing the content and tone of the complaint handling manual in response to perceived emotions to ensure an appropriate response.

[1408] This invention is a system that collects past customer service data and automatically generates a complaint handling manual using generative artificial intelligence (AI). The system includes a data collection module, a data processing module, a manual generation module, an emotion engine module, and a user interface (UI) module.

[1409] Data Collection Module

[1410] The server issues an SQL query to the company's database to collect past customer service data. Specifically, the query format is "SELECT FROM cs_responses WHERE date > '2022-01-01'". Furthermore, the user (administrator) uploads new complaint response data to the system in CSV file format. Specifically, the upload method uses the command "upload_file('new_cs_responses.csv')".

[1411] Data Processing Module

[1412] The server cleanses the collected or uploaded data. Data cleansing includes removing missing values ​​and formatting the data. Specific examples of operations include "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)." The server then inputs the cleansed data into a generative AI model to learn patterns and important keywords from the data. This process uses a machine learning library (e.g., TensorFlow, PyTorch) and executes operations such as "model.fit(data)" and "model.save('cs_model.h5')."

[1413] Emotion Engine Module

[1414] The server uses an emotion engine to extract emotions from the user's input voice or text. The emotion engine uses natural language processing technology and voice analysis technology. Specific examples of operations include "audio_emotion = emotion_engine.analyze_audio(user_input)" for voice input and "text_emotion = emotion_engine.analyze_text(user_input)" for text input.

[1415] Manual Generation Module

[1416] The server uses a trained AI model to extract keywords and patterns related to a specific scenario. An example is "keywords = model.extract_keywords(data)". The server then uses a generative AI model based on the extracted information to automatically generate a complaint handling manual. The generated manual includes specific response procedures and points to note, and the content and tone are adjusted based on the recognized emotions. For example, a manual is generated using the operation "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)". The server then saves the generated manual in a database or storage. An example is "save_manual_db('manual_2023_01', manual_text)".

[1417] User Interface Module

[1418] A user (new employee) searches for a specific complaint handling method via the user interface. An example of a specific prompt sentence is "search_manual('The product arrived damaged')". The terminal then sends a request to the server to retrieve and display the relevant manual. The server executes the query "SELECT FROM manuals WHERE keywords LIKE '%The product arrived damaged%'" and returns the results to the terminal. The results are displayed on the terminal in the form of "display_manual(result)".

[1419] Specific examples

[1420] For example, if a new employee is responding to a complaint that "the product arrived damaged," the user (new employee) accepts the complaint and uses the user interface to search for the problem. They enter the prompt "search_manual('The product arrived damaged')." The server extracts appropriate keywords from past data and generates a response manual based on those keywords. Furthermore, an emotion engine recognizes the user's (customer's) emotions and reflects them in the manual content. For example, if the customer is angry, a particularly polite and prompt response procedure is required. The terminal displays the generated manual, and the user refers to it to respond. This process enables a quick and accurate response to the complaint, leading to improved customer satisfaction.

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

[1422] Step 1:

[1423] The server issues an SQL query to the company's database to collect historical customer service data. Specifically, it executes the query "SELECT FROM cs_responses WHERE date > '2022-01-01'". This operation pulls historical customer service data into the server. The input is the database query result, and the output is the collected customer service data.

[1424] Step 2:

[1425] The user (administrator) uploads new complaint response data to the system in CSV file format. The specific upload method is to use the command "upload_file('new_cs_responses.csv')". This operation adds the new complaint response data to the system. The input is the CSV file, and the output is the new data saved in the system.

[1426] Step 3:

[1427] The server cleanses the collected or uploaded data. Data cleansing includes removing missing values ​​and formatting the data. Specific examples of operations include "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)". This operation results in formatted data with no missing values. The input is the collected data and uploaded data, and the output is the cleansed data.

[1428] Step 4:

[1429] The server inputs the cleansed data into a generative AI model, which learns patterns and important keywords from the data. This process uses machine learning libraries (e.g., TensorFlow, PyTorch). Specific examples of operations include "model.fit(data)" and "model.save('cs_model.h5')." This operation results in a trained AI model. The input is the cleansed data, and the output is the trained AI model.

[1430] Step 5:

[1431] The server uses an emotion engine to extract emotions from the user's input voice or text. The emotion engine uses natural language processing technology and voice analysis technology. Specific examples of operations include "audio_emotion = emotion_engine.analyze_audio(user_input)" for voice input and "text_emotion = emotion_engine.analyze_text(user_input)" for text input. This operation yields the extracted emotion data. The input is the user's voice or text, and the output is emotion data.

[1432] Step 6:

[1433] The server uses a trained AI model to extract keywords and patterns relevant to a specific scenario. An example is "keywords = model.extract_keywords(data)". This operation yields important keywords and patterns. The input is the trained AI model and cleansed data, and the output is the extracted keywords and patterns.

[1434] Step 7:

[1435] The server uses a generative AI model based on the extracted information to automatically generate a complaint handling manual. The generated manual includes specific response procedures and points to note, and the content and tone are adjusted based on the recognized emotions. An example of a specific operation is "manual_text = gpt.generate_manual(keywords, emotion=text_emotion)". This operation results in a generated complaint handling manual. The input is the extracted keywords, patterns, and emotion data, and the output is the generated manual.

[1436] Step 8:

[1437] The server saves the generated manual in a database or storage. An example is "save_manual_db('manual_2023_01', manual_text)". This operation saves the complaint handling manual. The input is the generated manual, and the output is the manual stored in the database.

[1438] Step 9:

[1439] A user (new employee) searches for a specific complaint handling method through the user interface. An example of a specific prompt sentence is "search_manual('The product arrived damaged')". This operation searches for the relevant complaint handling manual. The input is the search query, and the output is the search results.

[1440] Step 10:

[1441] The terminal sends a request to the server, retrieves the relevant manual, and displays it. The server executes the query "SELECT FROM manuals WHERE keywords LIKE '%product is damaged%'" and returns the results to the terminal. The results are displayed on the terminal in the form of "display_manual(result)". This operation provides the user with the procedure to follow. The input is the search results, and the output is the displayed manual.

[1442] (Application example 2)

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

[1444] Conventional complaint handling systems have the problem of being difficult to recognize customer emotions and respond appropriately. Furthermore, generating response procedures is slow, which makes new employees feel uneasy about handling complaints, especially in physical stores, where speed is required. Furthermore, the lack of voice input, which requires manual input, reduces the efficiency and accuracy of responses.

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

[1446] In this invention, the server includes a means for collecting past customer service data, a means for using generative artificial intelligence to learn from the collected customer service data, a means for voice input of the complaint details, a means for analyzing the customer's emotional state during the complaint handling process, and a means for including optimal response procedures in a complaint handling manual based on the analysis results. This enables improved efficiency and accuracy in complaint handling. Furthermore, by recognizing customer emotions in real time and providing optimal response procedures accordingly, improved customer satisfaction can be expected.

[1447] "Past customer service data" refers to all past data related to the customer service provided by a company, including, for example, complaint details, response history, and customer feedback.

[1448] "Means of collection" refers to the technological methods or devices used to obtain historical customer service data from a company's database or other data storage.

[1449] "Generative artificial intelligence" refers to artificial intelligence that has the ability to generate new information or manuals based on existing data, and includes, for example, machine learning models and natural language generation models.

[1450] "Means of learning" refers to the processing technology that inputs collected data into generative artificial intelligence and allows it to recognize patterns and trends.

[1451] "Means for automatically generating complaint handling manuals" refers to technology that automatically creates response procedures and guidelines for specific scenarios based on learned data.

[1452] "Means for storage" refers to the technology used to store the generated complaint handling manual in a database or storage device.

[1453] "User Interface" means the interface that enables a user to interact with a system and enter, retrieve, and display information.

[1454] "Means for searching and displaying" refers to a technology for searching the generated complaint handling manual through a user interface and displaying the results to the user.

[1455] "Voice input means" refers to the technology used to convert speech into text and input it into the system.

[1456] "Means for analyzing the emotional state of customers" refers to technology for recognizing and analyzing customer emotions from the content of complaints and conversations.

[1457] "Means including optimal response procedures" refers to the technology of incorporating appropriate response procedures into a complaint handling manual based on the analysis results.

[1458] The system for implementing this invention is composed of the following main modules. These modules work together to improve the quality of complaint handling.

[1459] 1. Data Collection Module

[1460] The server collects historical customer service data from the company's database. Specifically, it uses SQL queries to extract relevant data and imports it into the system. Administrators can also upload new data, for example in CSV file format. This additional data is used in the data processing module, which is described later.

[1461] 2. Data Processing Module

[1462] The server cleanses the collected data, removing missing values, and performs other formatting operations. The cleansed data is then fed into a generative artificial intelligence (AI) model to learn patterns and important keywords. This training process uses machine learning libraries (such as TensorFlow and PyTorch).

[1463] 3. Emotion Engine Module

[1464] The server converts the speech to text using a speech recognition API (such as Google Cloud Speech-to-Text). The converted text is then fed into an emotion engine, which uses natural language processing and speech analysis techniques to recognize emotional states (e.g., anger or sadness). This emotion data is then used in the manual generation process described below.

[1465] 4. Manual Generation Module

[1466] The server uses a trained generative AI model (such as OpenAI's GPT-3) to automatically generate a response manual based on a complaint scenario. This response procedure is adjusted based on the extracted keywords and recognized emotions. Depending on the emotional state, a particularly polite and careful response procedure may be incorporated.

[1467] 5. User Interface Module

[1468] Users (such as new employees) can use a smartphone, smart glasses, or head-mounted display to voice-input the details of a complaint. The voice data is sent to the server, and an appropriate response manual is then generated through the above-mentioned module. This manual is displayed through the user interface, allowing the user to respond based on the contents in real time.

[1469] As a concrete example, consider a case where a new employee uses smart glasses to handle complaints.

[1470] 1. The store clerk (user) says, "The product arrived broken."

[1471] 2. The server converts the speech to text and analyzes the sentiment using an emotion engine.

[1472] 3. The emotion engine detects "anger" and uses a generative AI model to generate an appropriate response manual.

[1473] 4. Specific instructions for how to proceed will be displayed on the smart glasses, such as "We apologize. We will immediately process your product exchange."

[1474] Example prompt sentence:

[1475] Complaint: The product arrived broken.

[1476] Customer Emotion: Anger

[1477] Generate the corresponding manual:

[1478] In this way, complaints can be dealt with promptly and appropriately, leading to improved customer satisfaction.

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

[1480] Step 1:

[1481] Data collection

[1482] The server collects historical customer service data from the company's database. Specifically, the server issues an SQL query (e.g., "SELECT FROM cs_responses WHERE date > '2022-01-01'") to retrieve relevant data. This allows data such as complaint details and response history to be collected. The input is the SQL query, and the output is a set of customer service data.

[1483] Step 2:

[1484] Uploading additional data

[1485] A user (administrator) uploads new complaint response data to the system. The file is provided in CSV format and is added to the system using the command (e.g., "upload_file('new_cs_responses.csv')"). The input is the new complaint response data file, and the output is the new data added to the database in the system.

[1486] Step 3:

[1487] Data Cleansing

[1488] The server cleanses the collected or uploaded data. It removes missing values ​​and formats the data. Specifically, the server performs operations such as "data = pd.read_csv('new_cs_responses.csv')" and "data.dropna(inplace=True)". The input is the collected data filter set, and the output is the cleansed dataset.

[1489] Step 4:

[1490] Data training

[1491] The server then inputs the cleansed data into a generative artificial intelligence (AI) model to learn patterns and important keywords from the data. This process uses machine learning libraries (e.g., TensorFlow, PyTorch) and specific operations such as "model.fit(data)" and "model.save('cs_model.h5')". The input is the cleansed data, and the output is a trained AI model.

[1492] Step 5:

[1493] Voice input

[1494] The user (store clerk) inputs the details of the complaint into a smartphone or smart glasses by voice. This voice data is sent to the server. The input is voice data, and the output is data converted from voice to text.

[1495] Step 6:

[1496] Emotion recognition

[1497] The server inputs the text data of the complaint content into the emotion engine and analyzes the customer's emotions. The emotion engine uses natural language processing and speech analysis technology to recognize emotional states (e.g., anger, sadness, joy, etc.). The input is the text data of the complaint content, and the output is the analyzed emotion data.

[1498] Step 7:

[1499] Manual Generation

[1500] The server uses a trained generative AI model to automatically generate a response manual based on a complaint scenario. Based on the complaint content and emotional data, it creates a prompt sentence and inputs it into the generative AI model. The generated manual includes specific response procedures such as, "We apologize. We will process the product exchange immediately." The input is the complaint content and emotional data, and the output is the generated response manual.

[1501] Step 8:

[1502] View the manual

[1503] The terminal (smartphone or smart glasses) receives the response manual generated from the server and displays it through the user interface. The user can then respond to the complaint quickly and accurately based on the displayed manual. The input is the generated response manual, and the output is the manual displayed to the user.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[1525] The following is further disclosed regarding the above embodiment.

[1526] (Claim 1)

[1527] a means of collecting historical customer service data;

[1528] a means for using generative artificial intelligence to learn from the collected customer service data;

[1529] A means for automatically generating a complaint handling manual based on the learning results;

[1530] A means for saving the generated complaint handling manual;

[1531] A means for searching and displaying the complaint handling manual generated via a user interface;

[1532] A system including:

[1533] (Claim 2)

[1534] 10. The system of claim 1, further comprising means for formatting and cleansing the collected customer service data.

[1535] (Claim 3)

[1536] 2. The system according to claim 1, further comprising means for embedding specific keywords and patterns in the generated complaint handling manual.

[1537] "Example 1"

[1538] (Claim 1)

[1539] a means of collecting historical customer service data;

[1540] a means for uploading collected customer service data;

[1541] a means for cleansing the uploaded data;

[1542] a means for learning from the cleansed data using generative artificial intelligence;

[1543] means for extracting keywords and patterns related to a particular scenario based on the learning results;

[1544] A means for automatically generating a complaint handling manual based on the extracted information;

[1545] A means for saving the generated complaint handling manual;

[1546] A means for saving the generated complaint handling manual;

[1547] A means for searching and displaying the complaint handling manual generated via a user interface;

[1548] A system including:

[1549] (Claim 2)

[1550] 10. The system of claim 1, further comprising means for formatting and cleansing the collected customer service data.

[1551] (Claim 3)

[1552] 2. The system according to claim 1, further comprising means for embedding specific keywords and patterns in the generated complaint handling manual.

[1553] "Application Example 1"

[1554] (Claim 1)

[1555] a means of collecting historical customer service data;

[1556] a means for using generative artificial intelligence to learn from the collected customer service data;

[1557] A means for automatically generating a complaint handling manual based on the learning results;

[1558] A means for saving the generated complaint handling manual;

[1559] A means for searching and displaying the complaint handling manual generated via a user interface;

[1560] A means for generating a manual for resolving errors and complaints that occur in the automation system in the factory;

[1561] A system including:

[1562] (Claim 2)

[1563] 10. The system of claim 1, further comprising means for formatting and cleansing the collected customer service data.

[1564] (Claim 3)

[1565] 2. The system according to claim 1, further comprising means for embedding specific keywords and patterns in the generated complaint handling manual.

[1566] "Example 2: Combining Emotion Engines"

[1567] (Claim 1)

[1568] a means of collecting historical customer service data;

[1569] A means of formatting and cleansing the collected customer service data;

[1570] A means for learning the collected customer service data using generative artificial intelligence;

[1571] A means for automatically generating a complaint handling manual based on the learning results;

[1572] A means for saving the generated complaint handling manual;

[1573] A means for searching and displaying the complaint handling manual generated via a user interface;

[1574] a means for recognizing the user's emotions and adjusting the content of the complaint handling manual based on the recognition result;

[1575] A system including:

[1576] (Claim 2)

[1577] 10. The system of claim 1, further comprising means for formatting and cleansing the collected customer service data.

[1578] (Claim 3)

[1579] 2. The system according to claim 1, further comprising means for embedding specific keywords and patterns in the generated complaint handling manual.

[1580] "Application example 2 when combining emotion engines"

[1581] (Claim 1)

[1582] a means of collecting historical customer service data;

[1583] a means for using generative artificial intelligence to learn from the collected customer service data;

[1584] A means for automatically generating a complaint handling manual based on the learning results;

[1585] A means for saving the generated complaint handling manual;

[1586] A means for searching and displaying the complaint handling manual generated via a user interface;

[1587] A means for inputting the content of a complaint by voice;

[1588] A means for analyzing the emotional state of a customer during a complaint handling process;

[1589] A means to include the optimal response procedure in the complaint response manual based on the analysis results;

[1590] A system including:

[1591] (Claim 2)

[1592] 10. The system of claim 1, further comprising means for formatting and cleansing the collected customer service data.

[1593] (Claim 3)

[1594] 2. The system according to claim 1, further comprising means for embedding specific keywords and patterns in the generated complaint handling manual. [Explanation of symbols]

[1595] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. a means of collecting historical customer service data; a means for using generative artificial intelligence to learn from the collected customer service data; A means for automatically generating a complaint handling manual based on the learning results; A means for saving the generated complaint handling manual; A means for searching and displaying the complaint handling manual generated via a user interface; A system including:

2. 10. The system of claim 1, further comprising means for formatting and cleansing the collected customer service data.

3. 2. The system according to claim 1, further comprising means for embedding specific keywords and patterns in the generated complaint handling manual.

Images