System

Abstract

A system is provided.SOLUTION: A system comprising: means for registering a feature of a commodity desired by a user; means for collecting commodity information from a plurality of e-commerce sites; means for normalizing the commodity information based on the registered feature using a generative AI model; means for recommending an optimum commodity from the normalized commodity information; and means for periodically presenting a recommendation result.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] With the recent spread of e-commerce, users can now purchase products from multiple online sales sites, but this has created the following problems. First, the same product may be offered at different prices and with different descriptions (e.g., color or size) on different sites, making it difficult to find what you really want. Second, searching for products one by one on various sites takes a lot of time and effort. To solve these problems, a system that allows users to easily find the products they want is needed. [Means for solving the problem]

[0005] The present invention provides the following means to solve the above problems: A system is provided that includes a means for a user to register the characteristics of products they want, a means for collecting product data from multiple e-commerce sites, a means for normalizing the product data based on the registered characteristics using a generative AI model, a means for recommending optimal products from the normalized product data, a means for periodically presenting the recommendation results, and a means for saving data on favorite products and using that data to improve the accuracy of future recommendations, thereby enabling users to easily find the products they really want.

[0006] "Means for users to register the characteristics of the products they want" is a mechanism that provides an interface for users to input characteristic information such as the product name, features, price range, and color, and register it in the system.

[0007] "Means for collecting product data from multiple e-commerce sites" refers to a system that includes technologies and methods for automatically collecting data on specific products from various online sales sites.

[0008] A "generative AI model" is an artificial intelligence model that analyzes collected product data and unifies different language notations, color notations, size notations, etc.

[0009] "Normalization methods" are mechanisms that use generative AI models to convert data with different representations into a unified format.

[0010] The "recommendation method" is a system that selects the most suitable product from collected data based on the characteristics of the product registered by the user and presents it to the user.

[0011] "Means for periodically presenting recommendation results" refers to a mechanism for notifying users of optimal products at regular intervals.

[0012] "Means for saving data on favorite products" is a mechanism that allows users to select their favorite products and save them in a database.

[0013] "Means to improve the accuracy of recommendations from next time onwards" refers to a system that analyzes saved favorite data and uses that data to improve the accuracy of recommendations from next time onwards. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0022] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0035] The present invention describes a specific embodiment of a system that allows a user to register the characteristics of a desired product and recommends optimal products based on product data collected from multiple e-commerce sites.

[0036] User characteristics registration

[0037] First, the user uses the interface on the device to input the characteristics of the product they want (e.g., product name, features, price range, color). The device receives this information and sends it to the server, which then stores the received characteristic data in a database.

[0038] Collecting and organizing product data

[0039] The server periodically collects product data from multiple e-commerce sites. This process is automated using APIs and web scraping technology. The collected product data is then analyzed using a generative AI model. The AI ​​model normalizes different language notations, colors, sizes, etc. into a unified format. This process ensures that the data in the database is stored in a consistent format.

[0040] Recommendation processing

[0041] Based on the characteristics registered by the user, the server searches the product data in the database and uses a generative AI model to select candidate products that match various attributes (price range, color, size, features, etc.). This generates an optimal product list and sends it to the device as a recommendation result.

[0042] Regular recommendation notifications

[0043] The server periodically notifies the device of new recommended products based on the user's settings. This notification is sent via the method selected by the user, such as email or in-app notification. The user can then check the details of the recommended products and decide whether to purchase them.

[0044] Register your favorite products and improve the accuracy of your next recommendation

[0045] When a user likes a product in the recommendation list and registers it as a "favorite," the device sends this information to the server. The server stores the favorite data in a database and uses it to improve the accuracy of future recommendations. This mechanism enables the system to provide more personalized recommendations that reflect the user's preferences and past tastes.

[0046] Specific examples

[0047] For example, if a user wants "red sneakers, price range 5,000 to 10,000 yen, size 26cm," they input these characteristics into their device and send them to the server. The server generates a list of relevant products based on data collected from e-commerce sites. The generated list includes products such as "red sneakers, price 7,000 yen, size 26cm," which are recommended to the user. If the user likes "red sneakers, price 7,500 yen, size 26cm" and saves it as a favorite, that information will be reflected in the next recommendation, providing even more accurate results.

[0048] The above is a specific embodiment for carrying out the present invention. This system allows users to efficiently find the most suitable product, saving time and effort.

[0049] The processing flow will be explained below.

[0050] Step 1:

[0051] User enters characteristics

[0052] The user opens the terminal interface and inputs characteristic information such as "product name," "features," "price range," and "color." The terminal temporarily stores this input data and provides a send button. When the user presses the send button, the terminal generates a request to send the input data to the server.

[0053] Step 2:

[0054] The server receives and stores the data

[0055] The server receives the user's input data sent from the device, analyzes the received data, and stores it as a new entry in the database.

[0056] Step 3:

[0057] The server collects product data

[0058] The server periodically collects new product data from multiple e-commerce sites, using APIs and web scraping technology to automatically retrieve product information from each site.

[0059] Step 4:

[0060] Normalization of collected data

[0061] The server uses a generative AI model to analyze the collected product data and normalize it into a unified format, specifically, standardizing language notation, color notation (e.g., brown vs. brown), size notation (e.g., medium vs. regular size), etc.

[0062] Step 5:

[0063] Storing normalized data

[0064] The server stores the normalized product data in a database, which is then used for recommendation processing.

[0065] Step 6:

[0066] Search and select recommended products

[0067] The server searches for products in the database based on the feature data registered by the user, and uses a generative AI model to select the most suitable product, taking into account multidimensional matches (price range, color, size, features, etc.).

[0068] Step 7:

[0069] Generate and send recommendation lists

[0070] The server generates a list of the selected optimal products and sends the generated recommendation list to the device via an API request.

[0071] Step 8:

[0072] Display of recommended products

[0073] The terminal displays the recommendation list received from the server on the user interface, allowing the user to check detailed information from this list.

[0074] Step 9:

[0075] Register your favorite products

[0076] The user selects a product from the recommendation list and clicks the "Favorite" button. The device generates a request to send the selected product data to the server.

[0077] Step 10:

[0078] Save and update favorite data

[0079] The server receives the favorite data sent by the user and stores it in a database. The stored data will be used for future recommendation processing.

[0080] Step 11:

[0081] Setting and sending regular recommendation notifications

[0082] The server periodically generates new recommended products based on the user's settings and sends them via the user's preferred notification method (email, in-app notification, etc.).

[0083] The above are the specific processing steps of a recommendation service program. This series of steps allows users to efficiently find the best products, saving time and effort.

[0084] Example 1

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

[0086] With the development of e-commerce, many products are sold on the Internet. However, it is difficult for users to find the best product from multiple e-commerce sites, and it takes time and effort. Furthermore, existing systems are not accurate enough in providing personalized product recommendations that match the user's preferences. Furthermore, unifying different languages ​​and notations is also an issue. There is a need for a system that can solve these issues and provide users with efficient and accurate product recommendations.

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

[0088] In this invention, the server includes means for registering the features of products desired by a user, means for collecting product data from multiple e-commerce sites, means for normalizing the product data based on the registered features using a generative AI model, means for recommending optimal products from the normalized product data, means for periodically presenting recommendation results, means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the saved data, and means for inputting the data into the generative AI model using prompt sentences. This enables users to efficiently find optimal products based on the features of their desired products and continuously receive highly accurate personalized recommendations.

[0089] "Means for users to register the characteristics of the product they want" refers to a means for users to input the attributes of the product they want (product name, features, price range, color, etc.) and send that information to the server.

[0090] "Means for collecting product data from multiple e-commerce sites" refers to means for automatically collecting product data from multiple e-commerce sites on the Internet using APIs or web scraping tools.

[0091] "Means for normalizing product data based on registered features using a generative AI model" refers to means for using a generative AI model to unify product data written in different notations or formats and convert it into a consistent data format.

[0092] The "means for recommending optimal products from normalized product data" refers to a means for searching a normalized product database for products that best match the characteristics registered by a user and recommending them.

[0093] The "means for periodically presenting recommendation results" is a means for notifying the user of new recommendation results at a frequency designated by the user.

[0094] "Means for saving data on favorite products and improving the accuracy of future recommendations based on that data" refers to a means for saving data on favorite products selected by users from a recommendation list and using that information to improve the accuracy of future recommendations.

[0095] "Means for inputting into a generative AI model using prompt sentences" refers to means for inputting the user's desired product features into a generative AI model as prompt sentences, and then utilizing the model to obtain or process optimal product data.

[0096] This invention describes a specific embodiment of a system that allows a user to register the features of a product they desire and recommends the most suitable product based on product data collected from multiple e-commerce sites.

[0097] First, the user uses the interface on their device (e.g., a smartphone or PC) to input the desired product's characteristics (e.g., product name, features, price range, color, etc.). The device then sends this information to the server in JSON format or similar. The server then stores the received characteristic data in a database (e.g., MongoDB or MySQL (registered trademark)).

[0098] Next, the server periodically collects product data from multiple e-commerce sites (e.g., general mail-order sites) using APIs or web scraping tools (e.g., BeautifulSoup, Selenium). The collected product data is temporarily stored in JSON format.

[0099] The collected data is analyzed and normalized using a generative AI model (e.g., GPT-3 (registered trademark)). The server uses this AI model to convert different language notations, color notations, size notations, etc. into a unified format. For example, variations in notations such as "red sneakers" and "Red Sneakers" are unified. This process ensures consistency of the data in the database.

[0100] The server searches for product data in the database based on the characteristics registered by the user. At this time, a generative AI model is used to calculate the degree of match between the user's characteristics and each product attribute (price range, color, size, features, etc.) to generate an optimal product list. For example, if a user registers "red sneakers, price range 5,000 to 10,000 yen, size 26cm," the server will search for products such as "Red Sneakers, Price 7,000 yen, Size 26cm." This list is sent to the user's device as a recommendation result.

[0101] The server periodically notifies the user of the recommendation results and sends them via the user's preferred method (email, in-app notification). Specifically, the server sends a product list along with the message "We have some red sneakers recommended for you!" The user can check this list on their device and access the detail page.

[0102] Furthermore, if a user likes an item in the recommendation list and registers it as a "favorite," the device sends this information to the server. The server saves the favorite data in a database and improves the accuracy of future recommendations. For example, if a user likes "red sneakers, price 7,500 yen, size 26cm" and registers it as a favorite, this information will be reflected in the next recommendation, providing more accurate results.

[0103] Here are some example prompts to input to a generative AI model:

[0104] "The user enters the desired product characteristics. Based on this, search your product database for the best products and generate a list of matching products.

[0105] Features: Red sneakers, price range: 5,000 to 10,000 yen, size 26cm

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

[0107] Step 1:

[0108] The user uses their own device to access a dedicated interface. Through the device's interface, the user inputs the characteristics of the product they want (product name, features, price range, color, etc.). Specifically, they input information such as "red sneakers, price range 5,000 to 10,000 yen, size 26cm." This characteristic data is organized in JSON format and sent to the server. The input data is temporarily saved by sending it to the server.

[0109] Step 2:

[0110] The server parses the feature data sent from the device and stores it in a database. For example, if a database such as MongoDB or MySQL is used, the feature data is converted into an appropriate format and stored in the corresponding table. Through this process, information about the products desired by the user is accumulated in the database.

[0111] Step 3:

[0112] The server periodically collects product data from multiple e-commerce sites using a scheduler (e.g., a Cron job). It obtains the product data using APIs or web scraping technologies such as BeautifulSoup or Selenium. The obtained data is temporarily saved in JSON format. The input of this step is raw data from the e-commerce sites, and the output is JSON data in a unified format.

[0113] Step 4:

[0114] The server inputs the collected product data into a generative AI model (e.g., GPT-3) and normalizes the data. Specifically, it unifies different spellings such as "red sneakers" and "Red Sneakers" to create consistency. The normalized data is stored in a database, and consistent product data is accumulated. The input is raw product data obtained from e-commerce sites, and the output is normalized product data.

[0115] Step 5:

[0116] The server searches for product data in the database based on the feature data registered by the user. At this time, a generative AI model is used to calculate the degree of match between the user's features and each product attribute (price range, color, size, features, etc.) to generate an optimal product list. For example, if a user registers "red sneakers, price range 5,000 to 10,000 yen, size 26cm," the server will search for the product "Red Sneakers, Price 7,000 yen, Size 26cm." The input is the feature data registered by the user, and the output is a list of matching products.

[0117] Step 6:

[0118] The server sends the generated recommendation results to the user's device. This notification is made by the method selected by the user (email, in-app notification, etc.). For example, the server sends a product list with the message "We have some red sneakers recommended for you!" The user can check this list on their device and access the detail page. The input is the generated recommendation results, and the output is the notification sent to the user.

[0119] Step 7:

[0120] Users register their favorite recommended products as "favorites." This information is sent from the device to the server. The server saves the favorite data in a database and improves the accuracy of future recommendations. This process provides more personalized recommendations that reflect the user's past preferences. Specifically, if a user registers "red sneakers, price 7,500 yen, size 26cm" as a favorite, that information will be reflected in the next recommendation. The input is information about the user's "favorite" products, and the output is improved accuracy from the next recommendation onwards.

[0121] (Application example 1)

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

[0123] In e-commerce, it is extremely time-consuming for users to effectively register the characteristics of their desired products and find the optimal product based on product data collected from multiple e-commerce sites. In particular, it is difficult to consistently use data from different sites, which limits the accuracy of efficient product recommendations. Another issue is the difficulty of notifying users of these recommendation results in a timely manner. Therefore, there is a need for a method that allows users to quickly and effectively find the optimal product and encourage them to make a purchase.

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

[0125] In this invention, the server includes means for registering the characteristics of products desired by a user, means for collecting product data from multiple e-commerce sites, means for normalizing the product data based on the registered characteristics using a generative AI model, means for notifying the user of recommendation results via a smartphone app, means for recommending optimal products from the normalized product data, means for periodically presenting the recommendation results, and means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the saved data. This allows users to easily register their desired products, quickly and accurately find optimal products based on data collected from multiple e-commerce sites, and effectively receive notifications via the smartphone app.

[0126] "Means for users to register the characteristics of products they want" is a system in which users input and record information about a specific product (e.g., product name, price range, color, size, etc.).

[0127] The "means for collecting product data from multiple e-commerce sites" is a system that automatically acquires product data from multiple e-commerce sites on the Internet.

[0128] "Generative AI model" is a general term for a model that uses artificial intelligence to analyze and process data, and is used particularly in the present invention for normalizing and recommending product data.

[0129] "Methods for normalizing product data based on characteristics" refers to a technology that converts information written differently into a unified format through intermediate data analysis, ensuring consistency.

[0130] "Means for notifying users of recommendation results via a smartphone app" refers to means for informing users of recommended product information via an application running on a smartphone.

[0131] "Means for recommending optimal products from normalized product data" is a function that selects and recommends products that best suit the user's needs based on data in a standardized format.

[0132] The "means for periodically presenting recommendation results" is a mechanism for providing the latest recommendation information to the user based on a set cycle.

[0133] "Means for saving data on favorite products and using that data to improve the accuracy of future recommendations" refers to a system that records information about products that users have marked as favorites and reflects that data in the next recommendation, thereby providing more accurate recommendations.

[0134] As an embodiment of the present invention, a system is constructed in which a user registers the characteristics of a product they want, and based on those characteristics, the system recommends the most suitable product from multiple e-commerce sites.

[0135] First, the user opens a dedicated application on their smartphone. Through the application's interface, the user inputs the characteristics of the product they want (e.g., product name, price range, color, size, etc.). This information is sent from the application to the server and stored in a database on the server.

[0136] The server then collects product data from multiple e-commerce sites. This is done automatically and periodically using each site's API or web scraping technology. The collected product data is analyzed using a generative AI model and normalized into a unified format, regardless of language, color, or size. This data normalization process ensures that the data in the database is stored in a consistent format.

[0137] Furthermore, the server searches product data in the database based on the characteristics registered by the user. Using a generative AI model, it selects candidate products that match various attributes (price range, color, size, features, etc.). An optimal product list is generated and notified to the user's smartphone as a recommendation result.

[0138] The server periodically notifies the smartphone app of new recommended products based on the user's settings. This notification is sent via the method selected by the user, such as in-app notification or email. The user can then check the details of the recommended products and decide whether to purchase them.

[0139] Furthermore, if a user likes a product in the recommendation list and registers it as a "favorite," the application sends this information to the server. The server then stores the favorite data in a database and uses it to improve the accuracy of future recommendations. This mechanism enables the system to provide more personalized recommendations that reflect the user's preferences and past tastes.

[0140] As a concrete example, suppose a user inputs the characteristics of "red sneakers, price range 5,000 to 10,000 yen, size 26cm." This information is sent to the server, and corresponding products are listed based on collected data from e-commerce sites. For example, a product such as "red sneakers, price 7,000 yen, size 26cm" may be recommended. If the user likes this product and registers it as a "favorite," that information will be reflected in the next recommendation.

[0141] An example of a prompt is as follows:

[0142] The user enters the characteristics of the product they want: red sneakers, price range 5,000 to 10,000 yen, size 26cm.

[0143] Collect product data from the following e-commerce sites: site1.com / api / products, site2.com / api / products.

[0144] Analyze and normalize the collected data to recommend matching products.

[0145] The hardware used includes smartphone devices, cloud servers (e.g., AWS (registered trademark), GCP), and databases (e.g., MySQL, PostgreSQL), and the software uses generative AI models (e.g., GPT series). In this way, users can efficiently find the best products, saving time and effort.

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

[0147] Step 1:

[0148] The user opens the application on their smartphone and enters the characteristics of the product they want (e.g. product name, price range, color, size, etc.). The entered data is sent to the server as a JSON format object. Input data: Product characteristic information entered by the user. Output data: User information in JSON format sent to the server.

[0149] Step 2:

[0150] The server stores the received user feature data in a database. Input data: User information in JSON format. Output data: User information stored in the database.

[0151] Step 3:

[0152] The server periodically collects product data using APIs and web scraping technology from e-commerce sites. The collected data is temporarily stored in local storage. Input data: Product data obtained from each e-commerce site. Output data: Product data stored in local storage.

[0153] Step 4:

[0154] Using a generative AI model, collected product data is analyzed and normalized into a unified format for language, color, size, etc. Input data: Raw data stored in local storage. Output data: Normalized product information.

[0155] Step 5:

[0156] The server stores the normalized data in a database and searches for products based on the user's registration information. Input data: normalized product data and user characteristic information. Output data: a list of products that match the user's characteristics.

[0157] Step 6:

[0158] Using a generative AI model, we select the products that best suit the user's characteristics and generate a recommendation list. Input data: User characteristics information and product data in the database. Output data: Recommendation list.

[0159] Step 7:

[0160] The server notifies the smartphone app of the generated recommendation list. The user receives the notification and checks the details. Input data: Recommendation list. Output data: Recommended products displayed on the smartphone app.

[0161] Step 8:

[0162] When a user likes a product in the recommendation list and registers it as a "favorite," that information is sent from the application to the server. Input data: Product information registered as a favorite. Output data: Favorite data sent to the server.

[0163] Step 9:

[0164] The server stores the favorite data in a database and uses it to improve the accuracy of recommendations from next time onwards. Input data: Favorite data. Output data: User profile with improved recommendation accuracy from next time onwards.

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

[0166] The present invention relates to a system that allows users to register the characteristics of products they desire and recommends optimal products based on product data collected from multiple e-commerce sites.Furthermore, we will explain in detail an embodiment in which the accuracy of recommendations is improved by combining an emotion engine that recognizes the user's emotions.

[0167] User characteristics registration

[0168] First, the user uses the interface on the device to input the characteristics of the product they want (product name, features, price range, color, etc.). The device receives this information and sends it to the server, which then stores the received characteristic data in a database.

[0169] Collecting and organizing product data

[0170] The server periodically collects product data from multiple e-commerce sites. This process is automated using APIs and web scraping technology. The collected product data is then analyzed using a generative AI model. The AI ​​model normalizes different language notations, colors, sizes, etc. into a unified format. This process ensures that the data in the database is stored in a consistent format.

[0171] Recommendation processing

[0172] Based on the user's registered characteristics, the server searches for product data in the database. Using a generative AI model, it selects the most suitable products, taking into account multidimensional matches (price range, color, size, features, etc.). This generates a list of the best products, which is then sent to the device as a recommendation.

[0173] Use of emotion engine

[0174] The emotion engine recognizes the user's emotional data and provides a means to further adjust the recommendation results based on this. For example, if the user expresses happiness, it will prioritize recommendations of products with positive reviews that match that emotion. Conversely, if the user expresses dissatisfaction, it will suggest problem-solving products that correspond to that emotion.

[0175] Regular recommendation notifications

[0176] Based on the user's settings, the server periodically notifies the device of new recommended products. This notification is sent via the method selected by the user, such as email or in-app notification. The user can then check the details of the recommended products and decide whether to purchase them.

[0177] Register your favorite products and improve the accuracy of your next recommendation

[0178] When a user likes a product in the recommendation list and registers it as a "favorite," the device sends this information to the server. The server stores the favorite data in a database and uses it to improve the accuracy of future recommendations. This mechanism enables the system to provide more personalized recommendations that reflect not only the user's preferences and past tastes, but also their emotional feedback.

[0179] Specific examples

[0180] For example, if a user wants "red sneakers, price range 5,000 to 10,000 yen, size 26cm," they input these characteristics into their terminal and send them to the server. The server generates a list of relevant products based on data collected from e-commerce sites. The generated list includes products such as "red sneakers, price 7,000 yen, size 26cm," which are recommended to the user.

[0181] Furthermore, if the emotion engine analyzes the user's facial expression and detects the emotion of joy, it will prioritize the listing of products with positive reviews that match that emotion.If a user likes "red sneakers, price 7,500 yen, size 26cm" and adds them to their favorites, that information will be reflected in the next recommendation, providing even more accurate results.

[0182] The above is a specific embodiment for implementing the present invention. This system allows users to efficiently find the best products, saving time and effort. Furthermore, the introduction of an emotion engine provides more appropriate recommendations based on the user's emotions.

[0183] The processing flow will be explained below.

[0184] Step 1:

[0185] User enters characteristics

[0186] The user opens the terminal interface and inputs characteristic information such as "product name," "features," "price range," and "color." The terminal temporarily stores this input data and provides a send button. When the user presses the send button, the terminal generates a request to send the input data to the server.

[0187] Step 2:

[0188] The server receives and stores the data

[0189] The server receives the user's input data sent from the device, analyzes the received data, and stores it as a new entry in the database.

[0190] Step 3:

[0191] The server collects product data

[0192] The server periodically collects new product data from multiple e-commerce sites, using APIs and web scraping technology to automatically retrieve product information from each site.

[0193] Step 4:

[0194] Normalization of collected data

[0195] The server uses a generative AI model to analyze the collected product data and normalize it into a unified format, specifically, standardizing language notation, color notation (e.g., brown vs. brown), size notation (e.g., medium vs. regular size), etc.

[0196] Step 5:

[0197] Storing normalized data

[0198] The server stores the normalized product data in a database, which is then used for recommendation processing.

[0199] Step 6:

[0200] Search and select recommended products

[0201] The server searches for products in the database based on the feature data registered by the user, and uses a generative AI model to select the most suitable product, taking into account multidimensional matches (price range, color, size, features, etc.).

[0202] Step 7:

[0203] Generate and send recommendation lists

[0204] The server generates a list of the selected optimal products and sends the generated recommendation list to the device via an API request.

[0205] Step 8:

[0206] Emotion data collection using an emotion engine

[0207] The device collects emotion data from the user's facial expressions and voice, which is then sent to the emotion engine in real time.

[0208] Step 9:

[0209] Recommendation adjustment based on emotional data

[0210] The server analyzes the emotion data sent from the emotion engine and adjusts the recommendation results. For example, if the emotion of joy is detected, it will prioritize products with positive reviews.

[0211] Step 10:

[0212] Display of recommended products

[0213] The terminal displays the recommendation list received from the server on the user interface, allowing the user to check detailed information from this list.

[0214] Step 11:

[0215] Register your favorite products

[0216] The user selects a product from the recommendation list and clicks the "Favorite" button. The device generates a request to send the selected product data to the server.

[0217] Step 12:

[0218] Save and update favorite data

[0219] The server receives the favorite data sent by the user and stores it in a database. The stored data will be used for future recommendation processing.

[0220] Step 13:

[0221] Setting and sending regular recommendation notifications

[0222] The server periodically generates new recommended products based on the user's settings and sends them via the user's preferred notification method (email, in-app notification, etc.).

[0223] These are the specific processing steps of a recommendation service program that incorporates an emotion engine. This series of steps allows users to efficiently find the best products, saving time and effort. Furthermore, the introduction of an emotion engine allows for more appropriate recommendations based on the user's emotions.

[0224] Example 2

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

[0226] Traditional e-commerce systems have difficulty identifying users' desired products and lack personalized recommendation based on their emotions. As a result, users have to spend a lot of time and effort to find suitable products. Furthermore, there is a need for an effective method to normalize collected data, record favorite products, and improve the accuracy of next recommendation.

[0227] The identification process by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes a means for registering the features of products desired by the user, a means for collecting product data from multiple e-commerce sites, a means for normalizing the product data based on the registered features using a generative AI model, a means for recommending optimal products from the normalized product data, a means for collecting user emotion data and reflecting the data in the recommendation results, a means for periodically presenting the recommendation results, and a means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the data. This allows the user to efficiently find optimal products and enables personalized recommendations based on emotions.

[0228] "Users" are ordinary consumers who use the system to search for products and register their characteristics.

[0229] "Features" refers to detailed information about the product desired by the user, specifically including product name, features, price range, color, size, and other conditions.

[0230] "E-commerce site" means a website that offers and allows people to purchase goods over the Internet. Examples include online marketplaces and retailer websites.

[0231] "Product Data" means information about a product collected from an e-commerce site, including details such as price, color, size, manufacturer, and ratings.

[0232] A "generative AI model" is an artificial intelligence model that uses machine learning and deep learning techniques to analyze product data and match it with user characteristics.

[0233] "Normalization" refers to converting collected data into a unified format, including standardization of different language notations, colors, sizes, etc.

[0234] "Recommendation" refers to presenting the most suitable product selected based on the user's characteristics.

[0235] "Emotion data" is information about the emotional state of a user collected from facial expressions, voice, and the like.

[0236] "Favorite products" refers to products that a user has particularly liked and registered, and this data is used to improve the accuracy of recommendations in the future.

[0237] This invention relates to a system that allows users to register the features of products they desire and recommends optimal products based on product data collected from multiple e-commerce sites, and further improves the accuracy of recommendations by combining it with an emotion engine that recognizes the user's emotions.The main components of this system are the user, a terminal, and a server.

[0238] First, the user uses the interface on the device to input the characteristics of the product they want. For example, if the user inputs "red sneakers, price range 5,000 to 10,000 yen, size 26cm," the data is sent from the device to the server. The device can be a typical device such as a smartphone, tablet, or PC. The input data is stored in a database including RAM.

[0239] The server, which is configured using Python or Java®, receives feature data sent from devices and stores it in a database. The server also periodically collects product data from multiple e-commerce sites using APIs and web scraping technology. The collected product data is analyzed using a generative AI model (e.g., TENSORFLOW® or PyTorch) to normalize different language notations, colors, sizes, etc. into a unified format. In this process, libraries such as Beautiful Soup and Scrapy are used for web scraping.

[0240] The server then searches for product data in the database based on the user's registered characteristics. Using a generative AI model, it selects the best product by considering multidimensional matches (price range, color, size, features, etc.). For example, if a user enters "red sneakers, price 7,000 yen, size 26cm," it will list products that match those criteria.

[0241] To utilize the emotion engine, the device uses sensors such as a camera and microphone to collect user emotional data. For emotion analysis, OpenCV and dlib libraries are used to analyze the user's facial expressions and voice to determine their emotional state. For example, if the user is smiling and expressing joy, this information is sent to the server, and based on that, products with positive reviews are prioritized for recommendation.

[0242] For periodic recommendation notifications, the server periodically selects new recommended products based on the user's settings and notifies them, for example, by sending emails or in-app notifications to the device using Twilio or Firebase Cloud Messaging.

[0243] Furthermore, when a user registers a product in the recommendation list as a "favorite," that information is sent from the device to the server and stored in a database. This allows this data to be reflected in future recommendations, enabling more personalized recommendations that take into account the user's preferences and emotional feedback.

[0244] Examples of prompts that may be used include:

[0245] "Red sneakers, price range 5,000 to 10,000 yen, size 26cm"

[0246] This system allows users to efficiently find the best products and provides personalized recommendations based on emotions, saving time and effort. In addition, the introduction of an emotion engine provides more appropriate recommendations based on the user's emotions.

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

[0248] Step 1:

[0249] The user inputs the characteristics of the product he or she desires into the terminal.

[0250] How it works: The user accesses the interface on their device and enters detailed information about the product they want (product name, features, price range, color, size, etc.).

[0251] Input: Product feature data entered by the user (e.g., "red sneakers, price range: 5,000 to 10,000 yen, size: 26 cm").

[0252] Output: The input feature data is saved on the device.

[0253] Step 2:

[0254] The terminal sends the input information to the server.

[0255] Operation: The device sends the characteristic data entered by the user to the server according to a protocol (e.g., HTTP POST request).

[0256] Input: The input feature data (e.g., JSON format feature data).

[0257] Output: The server receives the feature data.

[0258] Step 3:

[0259] The server stores the feature data in a database.

[0260] Operation: The server stores the received feature data in a database (e.g., MySQL, PostgreSQL).

[0261] Input: The received feature data (e.g., JSON formatted feature data).

[0262] Output: The feature data is stored in a database.

[0263] Step 4:

[0264] A server collects product data from e-commerce sites.

[0265] How it works: The server uses APIs and web scraping technologies (e.g. Beautiful Soup, Scrapy) to collect product data from multiple e-commerce sites.

[0266] Input: Configuration information for API requests and web scraping.

[0267] Output: Collected product data (e.g. product list in JSON format).

[0268] Step 5:

[0269] The server analyzes and normalizes the collected product data.

[0270] How it works: The server uses generative AI models (e.g., TensorFlow, PyTorch) to analyze collected product data and normalize different language notations, colors, sizes, etc. into a unified format.

[0271] Input: Collected product data (e.g. product list in JSON format).

[0272] Output: Normalized product data (e.g., JSON data in a unified format).

[0273] Step 6:

[0274] The server stores the normalized product data in a database.

[0275] How it works: The server parses and normalizes the product data and stores it in a database.

[0276] Input: Normalized product data (e.g., JSON data in a unified format).

[0277] Output: Normalized product data stored in a database.

[0278] Step 7:

[0279] The server searches for product data in a database.

[0280] Operation: Based on the characteristics registered by the user, the server searches for product data in the database.

[0281] Input: User feature data, product data in the database.

[0282] Output: A list of products that match the user's criteria.

[0283] Step 8:

[0284] A generative AI model selects the best products.

[0285] How it works: The server uses a generative AI model to select the best products, taking into account multi-dimensional matches (price range, color, size, features, etc.).

[0286] Input: Search result product list, generative AI model.

[0287] Output: A list of optimal products (e.g. ranked products).

[0288] Step 9:

[0289] The server sends the recommendation results to the terminal.

[0290] Operation: The selected optimal product list is sent to the device as a recommendation result, and the user can view it on the device.

[0291] Input: Best product list.

[0292] Output: The recommendation results are displayed on the terminal.

[0293] Step 10:

[0294] The device collects the user's emotional data.

[0295] How it works: The device uses sensors such as a camera and microphone to collect emotional data from the user's facial expressions and voice.

[0296] Input: User's facial and voice data.

[0297] Output: Emotion data.

[0298] Step 11:

[0299] The server analyzes the emotion data.

[0300] Operation: The server receives emotion data from the device and performs emotion analysis (e.g., OpenCV, dlib).

[0301] Input: Received emotion data.

[0302] Output: Parsed emotional state.

[0303] Step 12:

[0304] The server adjusts the recommendation results based on emotions.

[0305] How it works: Based on the analysis, the server adjusts the recommendation results. If the user expresses happiness, it prioritizes products with positive reviews.

[0306] Input: Parsed emotional state, recommendation results.

[0307] Output: The refined recommendation results.

[0308] Step 13:

[0309] The server periodically selects new recommended products based on user settings.

[0310] How it works: The server periodically selects new product recommendations based on user settings.

[0311] Input: User settings, latest product data from database.

[0312] Output: The new recommended product list.

[0313] Step 14:

[0314] The server notifies the terminal of recommended products.

[0315] How it works: The server uses Twilio or Firebase Cloud Messaging to notify the device of recommended products via email or in-app notifications.

[0316] Input: A new list of recommended products.

[0317] Output: A recommendation notification will be displayed on the device.

[0318] Step 15:

[0319] The user registers the recommended product as a "favorite."

[0320] How it works: The user selects an item from the recommendation list and adds it to their "favorites."

[0321] Input: Recommendation results, favorite selection operation.

[0322] Output: Favorites data is saved on the device.

[0323] Step 16:

[0324] The device sends the favorites data to the server.

[0325] Operation: The device sends the data registered in "Favorites" to the server.

[0326] Input: Favorites data.

[0327] Output: The server receives the favorites data.

[0328] Step 17:

[0329] The server stores the favorite data in a database and reflects it in the next recommendation.

[0330] How it works: The server stores the received favorite data in a database and uses that information in the next recommendation process.

[0331] Input: Favorites data.

[0332] Output: Favorite data stored in the database, improving the accuracy of next recommendations.

[0333] (Application example 2)

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

[0335] In modern e-commerce, it is difficult for users to quickly and accurately find the features of specific products they desire. Furthermore, typical recommendation systems are unable to take into account individual users' emotions, making it difficult to provide recommendations that fully meet their personal needs. This often leads to a poor user experience and dissatisfaction. Furthermore, it is difficult to unify product data from different e-commerce sites, making it difficult to accurately compare information in multiple languages ​​or with different formats.

[0336] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for registering the features of products desired by the user, means for collecting product data from multiple e-commerce sites, means for normalizing the product data based on the registered features using a generative AI model, means for recommending optimal products from the normalized product data, means for periodically presenting recommendation results, means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the saved data, and means for recognizing the user's emotions using a camera and reflecting the emotions in the recommendation results. This enables accurate product recommendations based on the features of products desired by the user, and personalized recommendations that take the user's emotions into consideration.

[0337] The "means for registering the characteristics of the product desired by the user" is an interface that allows the user to input information such as the name, features, price range, color, and size of the product they want and register it in the system.

[0338] "Means for collecting product data from multiple e-commerce sites" refers to a system that automatically obtains product-related data from multiple e-commerce sites using APIs and web scraping technology.

[0339] "Means for normalizing product data based on registered features using a generative AI model" refers to a function that analyzes acquired product data using a generative AI model and converts different language notations, color notations, size notations, etc. into a unified format.

[0340] The "means for recommending optimal products from normalized product data" is an algorithm that compares the features registered by the user with normalized product data and recommends the product that best matches them.

[0341] The "means for periodically presenting recommendation results" is a method for notifying a user of new recommendation results at regular intervals based on the settings of the registered user.

[0342] "Means of saving data on favorite products and using that data to improve the accuracy of future recommendations" refers to a function that saves information about products registered by users as "favorites" in a database and reflects that information in the recommendation algorithm from the next time onwards.

[0343] "Means of recognizing user emotions using a camera and reflecting them in recommendation results" refers to a technology that uses a camera on a smartphone or head-mounted display to analyze the user's facial expressions and movements, and adjusts the recommendation algorithm based on this emotional information.

[0344] The following describes in detail the embodiments of the present invention. The present invention relates to a system that allows users to register the features of products they desire and recommends optimal products based on product data collected from multiple e-commerce sites. Furthermore, by combining the system with an emotion engine that recognizes user emotions, the accuracy of recommendations can be improved.

[0345] First, the user uses the interface on the device to input the characteristics of the product they want (e.g., product name, features, price range, color, size, etc.). The device receives this information and sends it to the server, which then stores the received characteristic data in a database.

[0346] The server periodically collects product data from multiple e-commerce sites using APIs and web scraping technology. It uses Python's Beautiful Soup library to analyze web pages and extract product data. The collected product data is then analyzed using a generative AI model (e.g., TensorFlow, PyTorch, etc.). This model normalizes different language notations, colors, sizes, and other elements into a unified format.

[0347] Based on the characteristics registered by the user, the server searches for product data in the database, and uses a generative AI model to select the most suitable products, taking into account multidimensional matches such as price range, color, size, and features. This generates a list of the best products, which is then sent to the device as a recommendation result.

[0348] The emotion engine recognizes the user's emotional data using the camera on a smartphone or head-mounted display (HMD). This engine uses OpenCV to analyze the user's facial expressions in real time and read emotions such as joy or dissatisfaction. For example, if the user's emotion of joy is detected, the engine will prioritize recommending products with positive reviews that match that emotion. Conversely, if the user is feeling dissatisfied, it will suggest problem-solving products that correspond to that emotion.

[0349] As a concrete example, if a user desires "red sneakers, price range 5,000 to 10,000 yen, size 26cm," they input these characteristics into their device and send them to the server. The server generates a list of relevant products based on data collected from e-commerce sites. The generated list includes products such as "red sneakers, price 7,000 yen, size 26cm," which are recommended to the user. Furthermore, if the user likes "red sneakers, price 7,500 yen, size 26cm" and registers it as a favorite, this information will be reflected in the next recommendation, providing even more accurate results.

[0350] An example of a prompt for the generative AI model is, "Please normalize the name, price, color, and size of this product into a unified format." This provides users with an efficient way to find the best product, saving time and effort. Furthermore, the introduction of an emotion engine enables more appropriate recommendations based on the user's emotions.

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

[0352] Step 1:

[0353] The user uses the interface on the terminal to input the characteristics of the product they want (e.g., product name, features, price range, color, size, etc.). The input characteristic data is sent from the terminal to the server, which then receives detailed information about the product desired by the user.

[0354] Step 2:

[0355] The server collects product data from multiple e-commerce sites. It uses Python's Beautiful Soup library to perform web scraping and obtain product information (e.g., product name, price, color, size, features, etc.) from these sites. The collected data is stored in the server's database. The input is the URL of the e-commerce site, and the output is the collected product data.

[0356] Step 3:

[0357] The server analyzes the collected product data using a generative AI model and normalizes different language notations, color notations, size notations, etc. into a unified format. TensorFlow and PyTorch are used for the generative AI model. For example, if a color name is written as "red," "red," or "aka," they are unified into a common format: "red." The input is the collected product data, and the output is the normalized product data.

[0358] Step 4:

[0359] The server matches the features registered by the user with normalized product data to select the most suitable products. It uses a generative AI model to check for multidimensional matches such as price range, color, size, and features. Specifically, it compares the user's features with the features of products and lists products with high matching scores. The input is the features registered by the user and normalized product data, and the output is a list of the most suitable products.

[0360] Step 5:

[0361] The server sends the generated optimal product list to the device and presents the recommendation results to the user. The recommendation results are periodically notified to the user via email or in-app notifications. The user receives the notifications and can check detailed information about the recommended products. The input is the optimal product list, and the output is the recommendation notification to the user.

[0362] Step 6:

[0363] The emotion engine recognizes the user's emotions using the camera on a smartphone or head-mounted display (HMD). It uses OpenCV to analyze the user's facial expressions in real time and detect emotions such as joy or displeasure. This emotion data is sent to the server and reflected in the recommendation algorithm. The input is the camera image, and the output is the detected emotion data.

[0364] Step 7:

[0365] The server adjusts the recommendation results based on the user's emotional data and changes the priority of products according to the emotion. For example, if the user expresses joy, it will prioritize products with positive reviews, and if the user expresses dissatisfaction, it will suggest problem-solving products. The input is the emotional data and the optimal product list, and the output is a recommendation list adjusted according to the emotion.

[0366] Step 8:

[0367] Users register their favorite recommended products as "favorites." The device sends this information to the server, which then stores the favorite data in a database. By taking this favorite data into consideration when making recommendations from the next time onward, the accuracy of recommendations can be improved. The input is the information on the favorite products selected by the user, and the output is an updated database.

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

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

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

[0371] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0384] The present invention describes a specific embodiment of a system that allows a user to register the characteristics of a desired product and recommends optimal products based on product data collected from multiple e-commerce sites.

[0385] User characteristics registration

[0386] First, the user uses the interface on the device to input the characteristics of the product they want (e.g., product name, features, price range, color). The device receives this information and sends it to the server, which then stores the received characteristic data in a database.

[0387] Collecting and organizing product data

[0388] The server periodically collects product data from multiple e-commerce sites. This process is automated using APIs and web scraping technology. The collected product data is then analyzed using a generative AI model. The AI ​​model normalizes different language notations, colors, sizes, etc. into a unified format. This process ensures that the data in the database is stored in a consistent format.

[0389] Recommendation processing

[0390] Based on the characteristics registered by the user, the server searches the product data in the database and uses a generative AI model to select candidate products that match various attributes (price range, color, size, features, etc.). This generates an optimal product list and sends it to the device as a recommendation result.

[0391] Regular recommendation notifications

[0392] The server periodically notifies the device of new recommended products based on the user's settings. This notification is sent via the method selected by the user, such as email or in-app notification. The user can then check the details of the recommended products and decide whether to purchase them.

[0393] Register your favorite products and improve the accuracy of your next recommendation

[0394] When a user likes a product in the recommendation list and registers it as a "favorite," the device sends this information to the server. The server stores the favorite data in a database and uses it to improve the accuracy of future recommendations. This mechanism enables the system to provide more personalized recommendations that reflect the user's preferences and past tastes.

[0395] Specific examples

[0396] For example, if a user wants "red sneakers, price range 5,000 to 10,000 yen, size 26cm," they input these characteristics into their device and send them to the server. The server generates a list of relevant products based on data collected from e-commerce sites. The generated list includes products such as "red sneakers, price 7,000 yen, size 26cm," which are recommended to the user. If the user likes "red sneakers, price 7,500 yen, size 26cm" and saves it as a favorite, that information will be reflected in the next recommendation, providing even more accurate results.

[0397] The above is a specific embodiment for carrying out the present invention. This system allows users to efficiently find the most suitable product, saving time and effort.

[0398] The processing flow will be explained below.

[0399] Step 1:

[0400] User enters characteristics

[0401] The user opens the terminal interface and inputs characteristic information such as "product name," "features," "price range," and "color." The terminal temporarily stores this input data and provides a send button. When the user presses the send button, the terminal generates a request to send the input data to the server.

[0402] Step 2:

[0403] The server receives and stores the data

[0404] The server receives the user's input data sent from the device, analyzes the received data, and stores it as a new entry in the database.

[0405] Step 3:

[0406] The server collects product data

[0407] The server periodically collects new product data from multiple e-commerce sites, using APIs and web scraping technology to automatically retrieve product information from each site.

[0408] Step 4:

[0409] Normalization of collected data

[0410] The server uses a generative AI model to analyze the collected product data and normalize it into a unified format, specifically, standardizing language notation, color notation (e.g., brown vs. brown), size notation (e.g., medium vs. regular size), etc.

[0411] Step 5:

[0412] Storing normalized data

[0413] The server stores the normalized product data in a database, which is then used for recommendation processing.

[0414] Step 6:

[0415] Search and select recommended products

[0416] The server searches for products in the database based on the feature data registered by the user, and uses a generative AI model to select the most suitable product, taking into account multidimensional matches (price range, color, size, features, etc.).

[0417] Step 7:

[0418] Generate and send recommendation lists

[0419] The server generates a list of the selected optimal products and sends the generated recommendation list to the device via an API request.

[0420] Step 8:

[0421] Display of recommended products

[0422] The terminal displays the recommendation list received from the server on the user interface, allowing the user to check detailed information from this list.

[0423] Step 9:

[0424] Register your favorite products

[0425] The user selects a product from the recommendation list and clicks the "Favorite" button. The device generates a request to send the selected product data to the server.

[0426] Step 10:

[0427] Save and update favorite data

[0428] The server receives the favorite data sent by the user and stores it in a database. The stored data will be used for future recommendation processing.

[0429] Step 11:

[0430] Setting and sending regular recommendation notifications

[0431] The server periodically generates new recommended products based on the user's settings and sends them via the user's preferred notification method (email, in-app notification, etc.).

[0432] The above are the specific processing steps of a recommendation service program. This series of steps allows users to efficiently find the best products, saving time and effort.

[0433] Example 1

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

[0435] With the development of e-commerce, many products are sold on the Internet. However, it is difficult for users to find the best product from multiple e-commerce sites, and it takes time and effort. Furthermore, existing systems are not accurate enough in providing personalized product recommendations that match the user's preferences. Furthermore, unifying different languages ​​and notations is also an issue. There is a need for a system that can solve these issues and provide users with efficient and accurate product recommendations.

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

[0437] In this invention, the server includes means for registering the features of products desired by a user, means for collecting product data from multiple e-commerce sites, means for normalizing the product data based on the registered features using a generative AI model, means for recommending optimal products from the normalized product data, means for periodically presenting recommendation results, means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the saved data, and means for inputting the data into the generative AI model using prompt sentences. This enables users to efficiently find optimal products based on the features of their desired products and continuously receive highly accurate personalized recommendations.

[0438] "Means for users to register the characteristics of the product they want" refers to a means for users to input the attributes of the product they want (product name, features, price range, color, etc.) and send that information to the server.

[0439] "Means for collecting product data from multiple e-commerce sites" refers to means for automatically collecting product data from multiple e-commerce sites on the Internet using APIs or web scraping tools.

[0440] "Means for normalizing product data based on registered features using a generative AI model" refers to means for using a generative AI model to unify product data written in different notations or formats and convert it into a consistent data format.

[0441] The "means for recommending optimal products from normalized product data" refers to a means for searching a normalized product database for products that best match the characteristics registered by a user and recommending them.

[0442] The "means for periodically presenting recommendation results" is a means for notifying the user of new recommendation results at a frequency designated by the user.

[0443] "Means for saving data on favorite products and improving the accuracy of future recommendations based on that data" refers to a means for saving data on favorite products selected by users from a recommendation list and using that information to improve the accuracy of future recommendations.

[0444] "Means for inputting into a generative AI model using prompt sentences" refers to means for inputting the user's desired product features into a generative AI model as prompt sentences, and then utilizing the model to obtain or process optimal product data.

[0445] This invention describes a specific embodiment of a system that allows a user to register the features of a product they desire and recommends the most suitable product based on product data collected from multiple e-commerce sites.

[0446] First, the user uses the interface on their device (e.g., smartphone or PC) to input the desired product's characteristics (e.g., product name, features, price range, color, etc.). The device then sends this information to the server in JSON format, etc. The server then stores the received characteristic data in a database (e.g., MongoDB or MySQL).

[0447] Next, the server periodically collects product data from multiple e-commerce sites (e.g., general mail-order sites) using APIs or web scraping tools (e.g., BeautifulSoup, Selenium). The collected product data is temporarily stored in JSON format.

[0448] The collected data is analyzed and normalized using a generative AI model (e.g., GPT-3). The server uses this AI model to convert different language notations, color notations, size notations, etc. into a unified format. For example, variations in notations such as "red sneakers" and "Red Sneakers" are unified. This process ensures consistency of the data in the database.

[0449] The server searches for product data in the database based on the characteristics registered by the user. At this time, a generative AI model is used to calculate the degree of match between the user's characteristics and each product attribute (price range, color, size, features, etc.) to generate an optimal product list. For example, if a user registers "red sneakers, price range 5,000 to 10,000 yen, size 26cm," the server will search for products such as "Red Sneakers, Price 7,000 yen, Size 26cm." This list is sent to the user's device as a recommendation result.

[0450] The server periodically notifies the user of the recommendation results and sends them via the user's preferred method (email, in-app notification). Specifically, the server sends a product list along with the message "We have some red sneakers recommended for you!" The user can check this list on their device and access the detail page.

[0451] Furthermore, if a user likes an item in the recommendation list and registers it as a "favorite," the device sends this information to the server. The server saves the favorite data in a database and improves the accuracy of future recommendations. For example, if a user likes "red sneakers, price 7,500 yen, size 26cm" and registers it as a favorite, this information will be reflected in the next recommendation, providing more accurate results.

[0452] Here are some example prompts to input to a generative AI model:

[0453] "The user enters the desired product characteristics. Based on this, search your product database for the best products and generate a list of matching products.

[0454] Features: Red sneakers, price range: 5,000 to 10,000 yen, size 26cm

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

[0456] Step 1:

[0457] The user uses their own device to access a dedicated interface. Through the device's interface, the user inputs the characteristics of the product they want (product name, features, price range, color, etc.). Specifically, they input information such as "red sneakers, price range 5,000 to 10,000 yen, size 26cm." This characteristic data is organized in JSON format and sent to the server. The input data is temporarily saved by sending it to the server.

[0458] Step 2:

[0459] The server parses the feature data sent from the device and stores it in a database. For example, if a database such as MongoDB or MySQL is used, the feature data is converted into an appropriate format and stored in the corresponding table. Through this process, information about the products desired by the user is accumulated in the database.

[0460] Step 3:

[0461] The server periodically collects product data from multiple e-commerce sites using a scheduler (e.g., a Cron job). It obtains the product data using APIs or web scraping technologies such as BeautifulSoup or Selenium. The obtained data is temporarily saved in JSON format. The input of this step is raw data from the e-commerce sites, and the output is JSON data in a unified format.

[0462] Step 4:

[0463] The server inputs the collected product data into a generative AI model (e.g., GPT-3) and normalizes the data. Specifically, it unifies different spellings such as "red sneakers" and "Red Sneakers" to create consistency. The normalized data is stored in a database, and consistent product data is accumulated. The input is raw product data obtained from e-commerce sites, and the output is normalized product data.

[0464] Step 5:

[0465] The server searches for product data in the database based on the feature data registered by the user. At this time, a generative AI model is used to calculate the degree of match between the user's features and each product attribute (price range, color, size, features, etc.) to generate an optimal product list. For example, if a user registers "red sneakers, price range 5,000 to 10,000 yen, size 26cm," the server will search for the product "Red Sneakers, Price 7,000 yen, Size 26cm." The input is the feature data registered by the user, and the output is a list of matching products.

[0466] Step 6:

[0467] The server sends the generated recommendation results to the user's device. This notification is made by the method selected by the user (email, in-app notification, etc.). For example, the server sends a product list with the message "We have some red sneakers recommended for you!" The user can check this list on their device and access the detail page. The input is the generated recommendation results, and the output is the notification sent to the user.

[0468] Step 7:

[0469] Users register their favorite recommended products as "favorites." This information is sent from the device to the server. The server saves the favorite data in a database and improves the accuracy of future recommendations. This process provides more personalized recommendations that reflect the user's past preferences. Specifically, if a user registers "red sneakers, price 7,500 yen, size 26cm" as a favorite, that information will be reflected in the next recommendation. The input is information about the user's "favorite" products, and the output is improved accuracy from the next recommendation onwards.

[0470] (Application example 1)

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

[0472] In e-commerce, it is extremely time-consuming for users to effectively register the characteristics of their desired products and find the optimal product based on product data collected from multiple e-commerce sites. In particular, it is difficult to consistently use data from different sites, which limits the accuracy of efficient product recommendations. Another issue is the difficulty of notifying users of these recommendation results in a timely manner. Therefore, there is a need for a method that allows users to quickly and effectively find the optimal product and encourage them to make a purchase.

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

[0474] In this invention, the server includes means for registering the characteristics of products desired by a user, means for collecting product data from multiple e-commerce sites, means for normalizing the product data based on the registered characteristics using a generative AI model, means for notifying the user of recommendation results via a smartphone app, means for recommending optimal products from the normalized product data, means for periodically presenting the recommendation results, and means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the saved data. This allows users to easily register their desired products, quickly and accurately find optimal products based on data collected from multiple e-commerce sites, and effectively receive notifications via the smartphone app.

[0475] "Means for users to register the characteristics of products they want" is a system in which users input and record information about a specific product (e.g., product name, price range, color, size, etc.).

[0476] The "means for collecting product data from multiple e-commerce sites" is a system that automatically acquires product data from multiple e-commerce sites on the Internet.

[0477] "Generative AI model" is a general term for a model that uses artificial intelligence to analyze and process data, and is used particularly in the present invention for normalizing and recommending product data.

[0478] "Methods for normalizing product data based on characteristics" refers to a technology that converts information written differently into a unified format through intermediate data analysis, ensuring consistency.

[0479] "Means for notifying users of recommendation results via a smartphone app" refers to means for informing users of recommended product information via an application running on a smartphone.

[0480] "Means for recommending optimal products from normalized product data" is a function that selects and recommends products that best suit the user's needs based on data in a standardized format.

[0481] The "means for periodically presenting recommendation results" is a mechanism for providing the latest recommendation information to the user based on a set cycle.

[0482] "Means for saving data on favorite products and using that data to improve the accuracy of future recommendations" refers to a system that records information about products that users have marked as favorites and reflects that data in the next recommendation, thereby providing more accurate recommendations.

[0483] As an embodiment of the present invention, a system is constructed in which a user registers the characteristics of a product they want, and based on those characteristics, the system recommends the most suitable product from multiple e-commerce sites.

[0484] First, the user opens a dedicated application on their smartphone. Through the application's interface, the user inputs the characteristics of the product they want (e.g., product name, price range, color, size, etc.). This information is sent from the application to the server and stored in a database on the server.

[0485] The server then collects product data from multiple e-commerce sites. This is done automatically and periodically using each site's API or web scraping technology. The collected product data is analyzed using a generative AI model and normalized into a unified format, regardless of language, color, or size. This data normalization process ensures that the data in the database is stored in a consistent format.

[0486] Furthermore, the server searches product data in the database based on the characteristics registered by the user. Using a generative AI model, it selects candidate products that match various attributes (price range, color, size, features, etc.). An optimal product list is generated and notified to the user's smartphone as a recommendation result.

[0487] The server periodically notifies the smartphone app of new recommended products based on the user's settings. This notification is sent via the method selected by the user, such as in-app notification or email. The user can then check the details of the recommended products and decide whether to purchase them.

[0488] Furthermore, if a user likes a product in the recommendation list and registers it as a "favorite," the application sends this information to the server. The server then stores the favorite data in a database and uses it to improve the accuracy of future recommendations. This mechanism enables the system to provide more personalized recommendations that reflect the user's preferences and past tastes.

[0489] As a concrete example, suppose a user inputs the characteristics of "red sneakers, price range 5,000 to 10,000 yen, size 26cm." This information is sent to the server, and corresponding products are listed based on collected data from e-commerce sites. For example, a product such as "red sneakers, price 7,000 yen, size 26cm" may be recommended. If the user likes this product and registers it as a "favorite," that information will be reflected in the next recommendation.

[0490] An example of a prompt is as follows:

[0491] The user enters the characteristics of the product they want: red sneakers, price range 5,000 to 10,000 yen, size 26cm.

[0492] Collect product data from the following e-commerce sites: site1.com / api / products, site2.com / api / products.

[0493] Analyze and normalize the collected data to recommend matching products.

[0494] The hardware used includes smartphones, cloud servers (e.g., AWS, GCP), databases (e.g., MySQL, PostgreSQL), and software using generative AI models (e.g., GPT series). In this way, users can efficiently find the best products, saving time and effort.

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

[0496] Step 1:

[0497] The user opens the application on their smartphone and enters the characteristics of the product they want (e.g. product name, price range, color, size, etc.). The entered data is sent to the server as a JSON format object. Input data: Product characteristic information entered by the user. Output data: User information in JSON format sent to the server.

[0498] Step 2:

[0499] The server stores the received user feature data in a database. Input data: User information in JSON format. Output data: User information stored in the database.

[0500] Step 3:

[0501] The server periodically collects product data using APIs and web scraping technology from e-commerce sites. The collected data is temporarily stored in local storage. Input data: Product data obtained from each e-commerce site. Output data: Product data stored in local storage.

[0502] Step 4:

[0503] Using a generative AI model, collected product data is analyzed and normalized into a unified format for language, color, size, etc. Input data: Raw data stored in local storage. Output data: Normalized product information.

[0504] Step 5:

[0505] The server stores the normalized data in a database and searches for products based on the user's registration information. Input data: normalized product data and user characteristic information. Output data: a list of products that match the user's characteristics.

[0506] Step 6:

[0507] Using a generative AI model, we select the products that best suit the user's characteristics and generate a recommendation list. Input data: User characteristics information and product data in the database. Output data: Recommendation list.

[0508] Step 7:

[0509] The server notifies the smartphone app of the generated recommendation list. The user receives the notification and checks the details. Input data: Recommendation list. Output data: Recommended products displayed on the smartphone app.

[0510] Step 8:

[0511] When a user likes a product in the recommendation list and registers it as a "favorite," that information is sent from the application to the server. Input data: Product information registered as a favorite. Output data: Favorite data sent to the server.

[0512] Step 9:

[0513] The server stores the favorite data in a database and uses it to improve the accuracy of recommendations from next time onwards. Input data: Favorite data. Output data: User profile with improved recommendation accuracy from next time onwards.

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

[0515] The present invention relates to a system that allows users to register the characteristics of products they desire and recommends optimal products based on product data collected from multiple e-commerce sites.Furthermore, we will explain in detail an embodiment in which the accuracy of recommendations is improved by combining an emotion engine that recognizes the user's emotions.

[0516] User characteristics registration

[0517] First, the user uses the interface on the device to input the characteristics of the product they want (product name, features, price range, color, etc.). The device receives this information and sends it to the server, which then stores the received characteristic data in a database.

[0518] Collecting and organizing product data

[0519] The server periodically collects product data from multiple e-commerce sites. This process is automated using APIs and web scraping technology. The collected product data is then analyzed using a generative AI model. The AI ​​model normalizes different language notations, colors, sizes, etc. into a unified format. This process ensures that the data in the database is stored in a consistent format.

[0520] Recommendation processing

[0521] Based on the user's registered characteristics, the server searches for product data in the database. Using a generative AI model, it selects the most suitable products, taking into account multidimensional matches (price range, color, size, features, etc.). This generates a list of the best products, which is then sent to the device as a recommendation.

[0522] Use of emotion engine

[0523] The emotion engine recognizes the user's emotional data and provides a means to further adjust the recommendation results based on this. For example, if the user expresses happiness, it will prioritize recommendations of products with positive reviews that match that emotion. Conversely, if the user expresses dissatisfaction, it will suggest problem-solving products that correspond to that emotion.

[0524] Regular recommendation notifications

[0525] Based on the user's settings, the server periodically notifies the device of new recommended products. This notification is sent via the method selected by the user, such as email or in-app notification. The user can then check the details of the recommended products and decide whether to purchase them.

[0526] Register your favorite products and improve the accuracy of your next recommendation

[0527] When a user likes a product in the recommendation list and registers it as a "favorite," the device sends this information to the server. The server stores the favorite data in a database and uses it to improve the accuracy of future recommendations. This mechanism enables the system to provide more personalized recommendations that reflect not only the user's preferences and past tastes, but also their emotional feedback.

[0528] Specific examples

[0529] For example, if a user wants "red sneakers, price range 5,000 to 10,000 yen, size 26cm," they input these characteristics into their terminal and send them to the server. The server generates a list of relevant products based on data collected from e-commerce sites. The generated list includes products such as "red sneakers, price 7,000 yen, size 26cm," which are recommended to the user.

[0530] Furthermore, if the emotion engine analyzes the user's facial expression and detects the emotion of joy, it will prioritize the listing of products with positive reviews that match that emotion.If a user likes "red sneakers, price 7,500 yen, size 26cm" and adds them to their favorites, that information will be reflected in the next recommendation, providing even more accurate results.

[0531] The above is a specific embodiment for implementing the present invention. This system allows users to efficiently find the best products, saving time and effort. Furthermore, the introduction of an emotion engine provides more appropriate recommendations based on the user's emotions.

[0532] The processing flow will be explained below.

[0533] Step 1:

[0534] User enters characteristics

[0535] The user opens the terminal interface and inputs characteristic information such as "product name," "features," "price range," and "color." The terminal temporarily stores this input data and provides a send button. When the user presses the send button, the terminal generates a request to send the input data to the server.

[0536] Step 2:

[0537] The server receives and stores the data

[0538] The server receives the user's input data sent from the device, analyzes the received data, and stores it as a new entry in the database.

[0539] Step 3:

[0540] The server collects product data

[0541] The server periodically collects new product data from multiple e-commerce sites, using APIs and web scraping technology to automatically retrieve product information from each site.

[0542] Step 4:

[0543] Normalization of collected data

[0544] The server uses a generative AI model to analyze the collected product data and normalize it into a unified format, specifically, standardizing language notation, color notation (e.g., brown vs. brown), size notation (e.g., medium vs. regular size), etc.

[0545] Step 5:

[0546] Storing normalized data

[0547] The server stores the normalized product data in a database, which is then used for recommendation processing.

[0548] Step 6:

[0549] Search and select recommended products

[0550] The server searches for products in the database based on the feature data registered by the user, and uses a generative AI model to select the most suitable product, taking into account multidimensional matches (price range, color, size, features, etc.).

[0551] Step 7:

[0552] Generate and send recommendation lists

[0553] The server generates a list of the selected optimal products and sends the generated recommendation list to the device via an API request.

[0554] Step 8:

[0555] Emotion data collection using an emotion engine

[0556] The device collects emotion data from the user's facial expressions and voice, which is then sent to the emotion engine in real time.

[0557] Step 9:

[0558] Recommendation adjustment based on emotional data

[0559] The server analyzes the emotion data sent from the emotion engine and adjusts the recommendation results. For example, if the emotion of joy is detected, it will prioritize products with positive reviews.

[0560] Step 10:

[0561] Display of recommended products

[0562] The terminal displays the recommendation list received from the server on the user interface, allowing the user to check detailed information from this list.

[0563] Step 11:

[0564] Register your favorite products

[0565] The user selects a product from the recommendation list and clicks the "Favorite" button. The device generates a request to send the selected product data to the server.

[0566] Step 12:

[0567] Save and update favorite data

[0568] The server receives the favorite data sent by the user and stores it in a database. The stored data will be used for future recommendation processing.

[0569] Step 13:

[0570] Setting and sending regular recommendation notifications

[0571] The server periodically generates new recommended products based on the user's settings and sends them via the user's preferred notification method (email, in-app notification, etc.).

[0572] These are the specific processing steps of a recommendation service program that incorporates an emotion engine. This series of steps allows users to efficiently find the best products, saving time and effort. Furthermore, the introduction of an emotion engine allows for more appropriate recommendations based on the user's emotions.

[0573] Example 2

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

[0575] Traditional e-commerce systems have difficulty identifying users' desired products and lack personalized recommendation based on their emotions. As a result, users have to spend a lot of time and effort to find suitable products. Furthermore, there is a need for an effective method to normalize collected data, record favorite products, and improve the accuracy of next recommendation.

[0576] The identification process by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes a means for registering the features of products desired by the user, a means for collecting product data from multiple e-commerce sites, a means for normalizing the product data based on the registered features using a generative AI model, a means for recommending optimal products from the normalized product data, a means for collecting user emotion data and reflecting the data in the recommendation results, a means for periodically presenting the recommendation results, and a means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the data. This allows the user to efficiently find optimal products and enables personalized recommendations based on emotions.

[0577] "Users" are ordinary consumers who use the system to search for products and register their characteristics.

[0578] "Features" refers to detailed information about the product desired by the user, specifically including product name, features, price range, color, size, and other conditions.

[0579] "E-commerce site" means a website that offers and allows people to purchase goods over the Internet. Examples include online marketplaces and retailer websites.

[0580] "Product Data" means information about a product collected from an e-commerce site, including details such as price, color, size, manufacturer, and ratings.

[0581] A "generative AI model" is an artificial intelligence model that uses machine learning and deep learning techniques to analyze product data and match it with user characteristics.

[0582] "Normalization" refers to converting collected data into a unified format, including standardization of different language notations, colors, sizes, etc.

[0583] "Recommendation" refers to presenting the most suitable product selected based on the user's characteristics.

[0584] "Emotion data" is information about the emotional state of a user collected from facial expressions, voice, and the like.

[0585] "Favorite products" refers to products that a user has particularly liked and registered, and this data is used to improve the accuracy of recommendations in the future.

[0586] This invention relates to a system that allows users to register the features of products they desire and recommends optimal products based on product data collected from multiple e-commerce sites, and further improves the accuracy of recommendations by combining it with an emotion engine that recognizes the user's emotions.The main components of this system are the user, a terminal, and a server.

[0587] First, the user uses the interface on the device to input the characteristics of the product they want. For example, if the user inputs "red sneakers, price range 5,000 to 10,000 yen, size 26cm," the data is sent from the device to the server. The device can be a typical device such as a smartphone, tablet, or PC. The input data is stored in a database including RAM.

[0588] The server, which is configured using Python or Java, receives feature data sent from devices and stores it in a database. The server also periodically collects product data from multiple e-commerce sites using APIs and web scraping technology. The collected product data is analyzed using a generative AI model (e.g., TensorFlow or PyTorch) to normalize different language notations, colors, sizes, etc. into a unified format. In this process, libraries such as Beautiful Soup and Scrapy are used for web scraping.

[0589] The server then searches for product data in the database based on the user's registered characteristics. Using a generative AI model, it selects the best product by considering multidimensional matches (price range, color, size, features, etc.). For example, if a user enters "red sneakers, price 7,000 yen, size 26cm," it will list products that match those criteria.

[0590] To utilize the emotion engine, the device uses sensors such as a camera and microphone to collect user emotional data. For emotion analysis, OpenCV and dlib libraries are used to analyze the user's facial expressions and voice to determine their emotional state. For example, if the user is smiling and expressing joy, this information is sent to the server, and based on that, products with positive reviews are prioritized for recommendation.

[0591] For periodic recommendation notifications, the server periodically selects new recommended products based on the user's settings and notifies them, for example, by sending emails or in-app notifications to the device using Twilio or Firebase Cloud Messaging.

[0592] Furthermore, when a user registers a product in the recommendation list as a "favorite," that information is sent from the device to the server and stored in a database. This allows this data to be reflected in future recommendations, enabling more personalized recommendations that take into account the user's preferences and emotional feedback.

[0593] Examples of prompts that may be used include:

[0594] "Red sneakers, price range 5,000 to 10,000 yen, size 26cm"

[0595] This system allows users to efficiently find the best products and provides personalized recommendations based on emotions, saving time and effort. In addition, the introduction of an emotion engine provides more appropriate recommendations based on the user's emotions.

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

[0597] Step 1:

[0598] The user inputs the characteristics of the product he or she desires into the terminal.

[0599] How it works: The user accesses the interface on their device and enters detailed information about the product they want (product name, features, price range, color, size, etc.).

[0600] Input: Product feature data entered by the user (e.g., "red sneakers, price range: 5,000 to 10,000 yen, size: 26 cm").

[0601] Output: The input feature data is saved on the device.

[0602] Step 2:

[0603] The terminal sends the input information to the server.

[0604] Operation: The device sends the characteristic data entered by the user to the server according to a protocol (e.g., HTTP POST request).

[0605] Input: The input feature data (e.g., JSON format feature data).

[0606] Output: The server receives the feature data.

[0607] Step 3:

[0608] The server stores the feature data in a database.

[0609] Operation: The server stores the received feature data in a database (e.g., MySQL, PostgreSQL).

[0610] Input: The received feature data (e.g., JSON formatted feature data).

[0611] Output: The feature data is stored in a database.

[0612] Step 4:

[0613] A server collects product data from e-commerce sites.

[0614] How it works: The server uses APIs and web scraping technologies (e.g. Beautiful Soup, Scrapy) to collect product data from multiple e-commerce sites.

[0615] Input: Configuration information for API requests and web scraping.

[0616] Output: Collected product data (e.g. product list in JSON format).

[0617] Step 5:

[0618] The server analyzes and normalizes the collected product data.

[0619] How it works: The server uses generative AI models (e.g., TensorFlow, PyTorch) to analyze collected product data and normalize different language notations, colors, sizes, etc. into a unified format.

[0620] Input: Collected product data (e.g. product list in JSON format).

[0621] Output: Normalized product data (e.g., JSON data in a unified format).

[0622] Step 6:

[0623] The server stores the normalized product data in a database.

[0624] How it works: The server parses and normalizes the product data and stores it in a database.

[0625] Input: Normalized product data (e.g., JSON data in a unified format).

[0626] Output: Normalized product data stored in a database.

[0627] Step 7:

[0628] The server searches for product data in a database.

[0629] Operation: Based on the characteristics registered by the user, the server searches for product data in the database.

[0630] Input: User feature data, product data in the database.

[0631] Output: A list of products that match the user's criteria.

[0632] Step 8:

[0633] A generative AI model selects the best products.

[0634] How it works: The server uses a generative AI model to select the best products, taking into account multi-dimensional matches (price range, color, size, features, etc.).

[0635] Input: Search result product list, generative AI model.

[0636] Output: A list of optimal products (e.g. ranked products).

[0637] Step 9:

[0638] The server sends the recommendation results to the terminal.

[0639] Operation: The selected optimal product list is sent to the device as a recommendation result, and the user can view it on the device.

[0640] Input: Best product list.

[0641] Output: The recommendation results are displayed on the terminal.

[0642] Step 10:

[0643] The device collects the user's emotional data.

[0644] How it works: The device uses sensors such as a camera and microphone to collect emotional data from the user's facial expressions and voice.

[0645] Input: User's facial and voice data.

[0646] Output: Emotion data.

[0647] Step 11:

[0648] The server analyzes the emotion data.

[0649] Operation: The server receives emotion data from the device and performs emotion analysis (e.g., OpenCV, dlib).

[0650] Input: Received emotion data.

[0651] Output: Parsed emotional state.

[0652] Step 12:

[0653] The server adjusts the recommendation results based on emotions.

[0654] How it works: Based on the analysis, the server adjusts the recommendation results. If the user expresses happiness, it prioritizes products with positive reviews.

[0655] Input: Parsed emotional state, recommendation results.

[0656] Output: The refined recommendation results.

[0657] Step 13:

[0658] The server periodically selects new recommended products based on user settings.

[0659] How it works: The server periodically selects new product recommendations based on user settings.

[0660] Input: User settings, latest product data from database.

[0661] Output: The new recommended product list.

[0662] Step 14:

[0663] The server notifies the terminal of recommended products.

[0664] How it works: The server uses Twilio or Firebase Cloud Messaging to notify the device of recommended products via email or in-app notifications.

[0665] Input: A new list of recommended products.

[0666] Output: A recommendation notification will be displayed on the device.

[0667] Step 15:

[0668] The user registers the recommended product as a "favorite."

[0669] How it works: The user selects an item from the recommendation list and adds it to their "favorites."

[0670] Input: Recommendation results, favorite selection operation.

[0671] Output: Favorites data is saved on the device.

[0672] Step 16:

[0673] The device sends the favorites data to the server.

[0674] Operation: The device sends the data registered in "Favorites" to the server.

[0675] Input: Favorites data.

[0676] Output: The server receives the favorites data.

[0677] Step 17:

[0678] The server stores the favorite data in a database and reflects it in the next recommendation.

[0679] How it works: The server stores the received favorite data in a database and uses that information in the next recommendation process.

[0680] Input: Favorites data.

[0681] Output: Favorite data stored in the database, improving the accuracy of next recommendations.

[0682] (Application example 2)

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

[0684] In modern e-commerce, it is difficult for users to quickly and accurately find the features of specific products they desire. Furthermore, typical recommendation systems are unable to take into account individual users' emotions, making it difficult to provide recommendations that fully meet their personal needs. This often leads to a poor user experience and dissatisfaction. Furthermore, it is difficult to unify product data from different e-commerce sites, making it difficult to accurately compare information in multiple languages ​​or with different formats.

[0685] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for registering the features of products desired by the user, means for collecting product data from multiple e-commerce sites, means for normalizing the product data based on the registered features using a generative AI model, means for recommending optimal products from the normalized product data, means for periodically presenting recommendation results, means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the saved data, and means for recognizing the user's emotions using a camera and reflecting the emotions in the recommendation results. This enables accurate product recommendations based on the features of products desired by the user, and personalized recommendations that take the user's emotions into consideration.

[0686] The "means for registering the characteristics of the product desired by the user" is an interface that allows the user to input information such as the name, features, price range, color, and size of the product they want and register it in the system.

[0687] "Means for collecting product data from multiple e-commerce sites" refers to a system that automatically obtains product-related data from multiple e-commerce sites using APIs and web scraping technology.

[0688] "Means for normalizing product data based on registered features using a generative AI model" refers to a function that analyzes acquired product data using a generative AI model and converts different language notations, color notations, size notations, etc. into a unified format.

[0689] The "means for recommending optimal products from normalized product data" is an algorithm that compares the features registered by the user with normalized product data and recommends the product that best matches them.

[0690] The "means for periodically presenting recommendation results" is a method for notifying a user of new recommendation results at regular intervals based on the settings of the registered user.

[0691] "Means of saving data on favorite products and using that data to improve the accuracy of future recommendations" refers to a function that saves information about products registered by users as "favorites" in a database and reflects that information in the recommendation algorithm from the next time onwards.

[0692] "Means of recognizing user emotions using a camera and reflecting them in recommendation results" refers to a technology that uses a camera on a smartphone or head-mounted display to analyze the user's facial expressions and movements, and adjusts the recommendation algorithm based on this emotional information.

[0693] The following describes in detail the embodiments of the present invention. The present invention relates to a system that allows users to register the features of products they desire and recommends optimal products based on product data collected from multiple e-commerce sites. Furthermore, by combining the system with an emotion engine that recognizes user emotions, the accuracy of recommendations can be improved.

[0694] First, the user uses the interface on the device to input the characteristics of the product they want (e.g., product name, features, price range, color, size, etc.). The device receives this information and sends it to the server, which then stores the received characteristic data in a database.

[0695] The server periodically collects product data from multiple e-commerce sites using APIs and web scraping technology. It uses Python's Beautiful Soup library to analyze web pages and extract product data. The collected product data is then analyzed using a generative AI model (e.g., TensorFlow, PyTorch, etc.). This model normalizes different language notations, colors, sizes, and other elements into a unified format.

[0696] Based on the characteristics registered by the user, the server searches for product data in the database, and uses a generative AI model to select the most suitable products, taking into account multidimensional matches such as price range, color, size, and features. This generates a list of the best products, which is then sent to the device as a recommendation result.

[0697] The emotion engine recognizes the user's emotional data using the camera on a smartphone or head-mounted display (HMD). This engine uses OpenCV to analyze the user's facial expressions in real time and read emotions such as joy or dissatisfaction. For example, if the user's emotion of joy is detected, the engine will prioritize recommending products with positive reviews that match that emotion. Conversely, if the user is feeling dissatisfied, it will suggest problem-solving products that correspond to that emotion.

[0698] As a concrete example, if a user desires "red sneakers, price range 5,000 to 10,000 yen, size 26cm," they input these characteristics into their device and send them to the server. The server generates a list of relevant products based on data collected from e-commerce sites. The generated list includes products such as "red sneakers, price 7,000 yen, size 26cm," which are recommended to the user. Furthermore, if the user likes "red sneakers, price 7,500 yen, size 26cm" and registers it as a favorite, this information will be reflected in the next recommendation, providing even more accurate results.

[0699] An example of a prompt for the generative AI model is, "Please normalize the name, price, color, and size of this product into a unified format." This provides users with an efficient way to find the best product, saving time and effort. Furthermore, the introduction of an emotion engine enables more appropriate recommendations based on the user's emotions.

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

[0701] Step 1:

[0702] The user uses the interface on the terminal to input the characteristics of the product they want (e.g., product name, features, price range, color, size, etc.). The input characteristic data is sent from the terminal to the server, which then receives detailed information about the product desired by the user.

[0703] Step 2:

[0704] The server collects product data from multiple e-commerce sites. It uses Python's Beautiful Soup library to perform web scraping and obtain product information (e.g., product name, price, color, size, features, etc.) from these sites. The collected data is stored in the server's database. The input is the URL of the e-commerce site, and the output is the collected product data.

[0705] Step 3:

[0706] The server analyzes the collected product data using a generative AI model and normalizes different language notations, color notations, size notations, etc. into a unified format. TensorFlow and PyTorch are used for the generative AI model. For example, if a color name is written as "red," "red," or "aka," they are unified into a common format: "red." The input is the collected product data, and the output is the normalized product data.

[0707] Step 4:

[0708] The server matches the features registered by the user with normalized product data to select the most suitable products. It uses a generative AI model to check for multidimensional matches such as price range, color, size, and features. Specifically, it compares the user's features with the features of products and lists products with high matching scores. The input is the features registered by the user and normalized product data, and the output is a list of the most suitable products.

[0709] Step 5:

[0710] The server sends the generated optimal product list to the device and presents the recommendation results to the user. The recommendation results are periodically notified to the user via email or in-app notifications. The user receives the notifications and can check detailed information about the recommended products. The input is the optimal product list, and the output is the recommendation notification to the user.

[0711] Step 6:

[0712] The emotion engine recognizes the user's emotions using the camera on a smartphone or head-mounted display (HMD). It uses OpenCV to analyze the user's facial expressions in real time and detect emotions such as joy or displeasure. This emotion data is sent to the server and reflected in the recommendation algorithm. The input is the camera image, and the output is the detected emotion data.

[0713] Step 7:

[0714] The server adjusts the recommendation results based on the user's emotional data and changes the priority of products according to the emotion. For example, if the user expresses joy, it will prioritize products with positive reviews, and if the user expresses dissatisfaction, it will suggest problem-solving products. The input is the emotional data and the optimal product list, and the output is a recommendation list adjusted according to the emotion.

[0715] Step 8:

[0716] Users register their favorite recommended products as "favorites." The device sends this information to the server, which then stores the favorite data in a database. By taking this favorite data into consideration when making recommendations from the next time onward, the accuracy of recommendations can be improved. The input is the information on the favorite products selected by the user, and the output is an updated database.

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

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

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

[0720] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0733] The present invention describes a specific embodiment of a system that allows a user to register the characteristics of a desired product and recommends optimal products based on product data collected from multiple e-commerce sites.

[0734] User characteristics registration

[0735] First, the user uses the interface on the device to input the characteristics of the product they want (e.g., product name, features, price range, color). The device receives this information and sends it to the server, which then stores the received characteristic data in a database.

[0736] Collecting and organizing product data

[0737] The server periodically collects product data from multiple e-commerce sites. This process is automated using APIs and web scraping technology. The collected product data is then analyzed using a generative AI model. The AI ​​model normalizes different language notations, colors, sizes, etc. into a unified format. This process ensures that the data in the database is stored in a consistent format.

[0738] Recommendation processing

[0739] Based on the characteristics registered by the user, the server searches the product data in the database and uses a generative AI model to select candidate products that match various attributes (price range, color, size, features, etc.). This generates an optimal product list and sends it to the device as a recommendation result.

[0740] Regular recommendation notifications

[0741] The server periodically notifies the device of new recommended products based on the user's settings. This notification is sent via the method selected by the user, such as email or in-app notification. The user can then check the details of the recommended products and decide whether to purchase them.

[0742] Register your favorite products and improve the accuracy of your next recommendation

[0743] When a user likes a product in the recommendation list and registers it as a "favorite," the device sends this information to the server. The server stores the favorite data in a database and uses it to improve the accuracy of future recommendations. This mechanism enables the system to provide more personalized recommendations that reflect the user's preferences and past tastes.

[0744] Specific examples

[0745] For example, if a user wants "red sneakers, price range 5,000 to 10,000 yen, size 26cm," they input these characteristics into their device and send them to the server. The server generates a list of relevant products based on data collected from e-commerce sites. The generated list includes products such as "red sneakers, price 7,000 yen, size 26cm," which are recommended to the user. If the user likes "red sneakers, price 7,500 yen, size 26cm" and saves it as a favorite, that information will be reflected in the next recommendation, providing even more accurate results.

[0746] The above is a specific embodiment for carrying out the present invention. This system allows users to efficiently find the most suitable product, saving time and effort.

[0747] The processing flow will be explained below.

[0748] Step 1:

[0749] User enters characteristics

[0750] The user opens the terminal interface and inputs characteristic information such as "product name," "features," "price range," and "color." The terminal temporarily stores this input data and provides a send button. When the user presses the send button, the terminal generates a request to send the input data to the server.

[0751] Step 2:

[0752] The server receives and stores the data

[0753] The server receives the user's input data sent from the device, analyzes the received data, and stores it as a new entry in the database.

[0754] Step 3:

[0755] The server collects product data

[0756] The server periodically collects new product data from multiple e-commerce sites, using APIs and web scraping technology to automatically retrieve product information from each site.

[0757] Step 4:

[0758] Normalization of collected data

[0759] The server uses a generative AI model to analyze the collected product data and normalize it into a unified format, specifically, standardizing language notation, color notation (e.g., brown vs. brown), size notation (e.g., medium vs. regular size), etc.

[0760] Step 5:

[0761] Storing normalized data

[0762] The server stores the normalized product data in a database, which is then used for recommendation processing.

[0763] Step 6:

[0764] Search and select recommended products

[0765] The server searches for products in the database based on the feature data registered by the user, and uses a generative AI model to select the most suitable product, taking into account multidimensional matches (price range, color, size, features, etc.).

[0766] Step 7:

[0767] Generate and send recommendation lists

[0768] The server generates a list of the selected optimal products and sends the generated recommendation list to the device via an API request.

[0769] Step 8:

[0770] Display of recommended products

[0771] The terminal displays the recommendation list received from the server on the user interface, allowing the user to check detailed information from this list.

[0772] Step 9:

[0773] Register your favorite products

[0774] The user selects a product from the recommendation list and clicks the "Favorite" button. The device generates a request to send the selected product data to the server.

[0775] Step 10:

[0776] Save and update favorite data

[0777] The server receives the favorite data sent by the user and stores it in a database. The stored data will be used for future recommendation processing.

[0778] Step 11:

[0779] Setting and sending regular recommendation notifications

[0780] The server periodically generates new recommended products based on the user's settings and sends them via the user's preferred notification method (email, in-app notification, etc.).

[0781] The above are the specific processing steps of a recommendation service program. This series of steps allows users to efficiently find the best products, saving time and effort.

[0782] Example 1

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

[0784] With the development of e-commerce, many products are sold on the Internet. However, it is difficult for users to find the best product from multiple e-commerce sites, and it takes time and effort. Furthermore, existing systems are not accurate enough in providing personalized product recommendations that match the user's preferences. Furthermore, unifying different languages ​​and notations is also an issue. There is a need for a system that can solve these issues and provide users with efficient and accurate product recommendations.

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

[0786] In this invention, the server includes means for registering the features of products desired by a user, means for collecting product data from multiple e-commerce sites, means for normalizing the product data based on the registered features using a generative AI model, means for recommending optimal products from the normalized product data, means for periodically presenting recommendation results, means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the saved data, and means for inputting the data into the generative AI model using prompt sentences. This enables users to efficiently find optimal products based on the features of their desired products and continuously receive highly accurate personalized recommendations.

[0787] "Means for users to register the characteristics of the product they want" refers to a means for users to input the attributes of the product they want (product name, features, price range, color, etc.) and send that information to the server.

[0788] "Means for collecting product data from multiple e-commerce sites" refers to means for automatically collecting product data from multiple e-commerce sites on the Internet using APIs or web scraping tools.

[0789] "Means for normalizing product data based on registered features using a generative AI model" refers to means for using a generative AI model to unify product data written in different notations or formats and convert it into a consistent data format.

[0790] The "means for recommending optimal products from normalized product data" refers to a means for searching a normalized product database for products that best match the characteristics registered by a user and recommending them.

[0791] The "means for periodically presenting recommendation results" is a means for notifying the user of new recommendation results at a frequency designated by the user.

[0792] "Means for saving data on favorite products and improving the accuracy of future recommendations based on that data" refers to a means for saving data on favorite products selected by users from a recommendation list and using that information to improve the accuracy of future recommendations.

[0793] "Means for inputting into a generative AI model using prompt sentences" refers to means for inputting the user's desired product features into a generative AI model as prompt sentences, and then utilizing the model to obtain or process optimal product data.

[0794] This invention describes a specific embodiment of a system that allows a user to register the features of a product they desire and recommends the most suitable product based on product data collected from multiple e-commerce sites.

[0795] First, the user uses the interface on their device (e.g., smartphone or PC) to input the desired product's characteristics (e.g., product name, features, price range, color, etc.). The device then sends this information to the server in JSON format, etc. The server then stores the received characteristic data in a database (e.g., MongoDB or MySQL).

[0796] Next, the server periodically collects product data from multiple e-commerce sites (e.g., general mail-order sites) using APIs or web scraping tools (e.g., BeautifulSoup, Selenium). The collected product data is temporarily stored in JSON format.

[0797] The collected data is analyzed and normalized using a generative AI model (e.g., GPT-3). The server uses this AI model to convert different language notations, color notations, size notations, etc. into a unified format. For example, variations in notations such as "red sneakers" and "Red Sneakers" are unified. This process ensures consistency of the data in the database.

[0798] The server searches for product data in the database based on the characteristics registered by the user. At this time, a generative AI model is used to calculate the degree of match between the user's characteristics and each product attribute (price range, color, size, features, etc.) to generate an optimal product list. For example, if a user registers "red sneakers, price range 5,000 to 10,000 yen, size 26cm," the server will search for products such as "Red Sneakers, Price 7,000 yen, Size 26cm." This list is sent to the user's device as a recommendation result.

[0799] The server periodically notifies the user of the recommendation results and sends them via the user's preferred method (email, in-app notification). Specifically, the server sends a product list along with the message "We have some red sneakers recommended for you!" The user can check this list on their device and access the detail page.

[0800] Furthermore, if a user likes an item in the recommendation list and registers it as a "favorite," the device sends this information to the server. The server saves the favorite data in a database and improves the accuracy of future recommendations. For example, if a user likes "red sneakers, price 7,500 yen, size 26cm" and registers it as a favorite, this information will be reflected in the next recommendation, providing more accurate results.

[0801] Here are some example prompts to input to a generative AI model:

[0802] "The user enters the desired product characteristics. Based on this, search your product database for the best products and generate a list of matching products.

[0803] Features: Red sneakers, price range: 5,000 to 10,000 yen, size 26cm

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

[0805] Step 1:

[0806] The user uses their own device to access a dedicated interface. Through the device's interface, the user inputs the characteristics of the product they want (product name, features, price range, color, etc.). Specifically, they input information such as "red sneakers, price range 5,000 to 10,000 yen, size 26cm." This characteristic data is organized in JSON format and sent to the server. The input data is temporarily saved by sending it to the server.

[0807] Step 2:

[0808] The server parses the feature data sent from the device and stores it in a database. For example, if a database such as MongoDB or MySQL is used, the feature data is converted into an appropriate format and stored in the corresponding table. Through this process, information about the products desired by the user is accumulated in the database.

[0809] Step 3:

[0810] The server periodically collects product data from multiple e-commerce sites using a scheduler (e.g., a Cron job). It obtains the product data using APIs or web scraping technologies such as BeautifulSoup or Selenium. The obtained data is temporarily saved in JSON format. The input of this step is raw data from the e-commerce sites, and the output is JSON data in a unified format.

[0811] Step 4:

[0812] The server inputs the collected product data into a generative AI model (e.g., GPT-3) and normalizes the data. Specifically, it unifies different spellings such as "red sneakers" and "Red Sneakers" to create consistency. The normalized data is stored in a database, and consistent product data is accumulated. The input is raw product data obtained from e-commerce sites, and the output is normalized product data.

[0813] Step 5:

[0814] The server searches for product data in the database based on the feature data registered by the user. At this time, a generative AI model is used to calculate the degree of match between the user's features and each product attribute (price range, color, size, features, etc.) to generate an optimal product list. For example, if a user registers "red sneakers, price range 5,000 to 10,000 yen, size 26cm," the server will search for the product "Red Sneakers, Price 7,000 yen, Size 26cm." The input is the feature data registered by the user, and the output is a list of matching products.

[0815] Step 6:

[0816] The server sends the generated recommendation results to the user's device. This notification is made by the method selected by the user (email, in-app notification, etc.). For example, the server sends a product list with the message "We have some red sneakers recommended for you!" The user can check this list on their device and access the detail page. The input is the generated recommendation results, and the output is the notification sent to the user.

[0817] Step 7:

[0818] Users register their favorite recommended products as "favorites." This information is sent from the device to the server. The server saves the favorite data in a database and improves the accuracy of future recommendations. This process provides more personalized recommendations that reflect the user's past preferences. Specifically, if a user registers "red sneakers, price 7,500 yen, size 26cm" as a favorite, that information will be reflected in the next recommendation. The input is information about the user's "favorite" products, and the output is improved accuracy from the next recommendation onwards.

[0819] (Application example 1)

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

[0821] In e-commerce, it is extremely time-consuming for users to effectively register the characteristics of their desired products and find the optimal product based on product data collected from multiple e-commerce sites. In particular, it is difficult to consistently use data from different sites, which limits the accuracy of efficient product recommendations. Another issue is the difficulty of notifying users of these recommendation results in a timely manner. Therefore, there is a need for a method that allows users to quickly and effectively find the optimal product and encourage them to make a purchase.

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

[0823] In this invention, the server includes means for registering the characteristics of products desired by a user, means for collecting product data from multiple e-commerce sites, means for normalizing the product data based on the registered characteristics using a generative AI model, means for notifying the user of recommendation results via a smartphone app, means for recommending optimal products from the normalized product data, means for periodically presenting the recommendation results, and means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the saved data. This allows users to easily register their desired products, quickly and accurately find optimal products based on data collected from multiple e-commerce sites, and effectively receive notifications via the smartphone app.

[0824] "Means for users to register the characteristics of products they want" is a system in which users input and record information about a specific product (e.g., product name, price range, color, size, etc.).

[0825] The "means for collecting product data from multiple e-commerce sites" is a system that automatically acquires product data from multiple e-commerce sites on the Internet.

[0826] "Generative AI model" is a general term for a model that uses artificial intelligence to analyze and process data, and is used particularly in the present invention for normalizing and recommending product data.

[0827] "Methods for normalizing product data based on characteristics" refers to a technology that converts information written differently into a unified format through intermediate data analysis, ensuring consistency.

[0828] "Means for notifying users of recommendation results via a smartphone app" refers to means for informing users of recommended product information via an application running on a smartphone.

[0829] "Means for recommending optimal products from normalized product data" is a function that selects and recommends products that best suit the user's needs based on data in a standardized format.

[0830] The "means for periodically presenting recommendation results" is a mechanism for providing the latest recommendation information to the user based on a set cycle.

[0831] "Means for saving data on favorite products and using that data to improve the accuracy of future recommendations" refers to a system that records information about products that users have marked as favorites and reflects that data in the next recommendation, thereby providing more accurate recommendations.

[0832] As an embodiment of the present invention, a system is constructed in which a user registers the characteristics of a product they want, and based on those characteristics, the system recommends the most suitable product from multiple e-commerce sites.

[0833] First, the user opens a dedicated application on their smartphone. Through the application's interface, the user inputs the characteristics of the product they want (e.g., product name, price range, color, size, etc.). This information is sent from the application to the server and stored in a database on the server.

[0834] The server then collects product data from multiple e-commerce sites. This is done automatically and periodically using each site's API or web scraping technology. The collected product data is analyzed using a generative AI model and normalized into a unified format, regardless of language, color, or size. This data normalization process ensures that the data in the database is stored in a consistent format.

[0835] Furthermore, the server searches product data in the database based on the characteristics registered by the user. Using a generative AI model, it selects candidate products that match various attributes (price range, color, size, features, etc.). An optimal product list is generated and notified to the user's smartphone as a recommendation result.

[0836] The server periodically notifies the smartphone app of new recommended products based on the user's settings. This notification is sent via the method selected by the user, such as in-app notification or email. The user can then check the details of the recommended products and decide whether to purchase them.

[0837] Furthermore, if a user likes a product in the recommendation list and registers it as a "favorite," the application sends this information to the server. The server then stores the favorite data in a database and uses it to improve the accuracy of future recommendations. This mechanism enables the system to provide more personalized recommendations that reflect the user's preferences and past tastes.

[0838] As a concrete example, suppose a user inputs the characteristics of "red sneakers, price range 5,000 to 10,000 yen, size 26cm." This information is sent to the server, and corresponding products are listed based on collected data from e-commerce sites. For example, a product such as "red sneakers, price 7,000 yen, size 26cm" may be recommended. If the user likes this product and registers it as a "favorite," that information will be reflected in the next recommendation.

[0839] An example of a prompt is as follows:

[0840] The user enters the characteristics of the product they want: red sneakers, price range 5,000 to 10,000 yen, size 26cm.

[0841] Collect product data from the following e-commerce sites: site1.com / api / products, site2.com / api / products.

[0842] Analyze and normalize the collected data to recommend matching products.

[0843] The hardware used includes smartphones, cloud servers (e.g., AWS, GCP), databases (e.g., MySQL, PostgreSQL), and software using generative AI models (e.g., GPT series). In this way, users can efficiently find the best products, saving time and effort.

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

[0845] Step 1:

[0846] The user opens the application on their smartphone and enters the characteristics of the product they want (e.g. product name, price range, color, size, etc.). The entered data is sent to the server as a JSON format object. Input data: Product characteristic information entered by the user. Output data: User information in JSON format sent to the server.

[0847] Step 2:

[0848] The server stores the received user feature data in a database. Input data: User information in JSON format. Output data: User information stored in the database.

[0849] Step 3:

[0850] The server periodically collects product data using APIs and web scraping technology from e-commerce sites. The collected data is temporarily stored in local storage. Input data: Product data obtained from each e-commerce site. Output data: Product data stored in local storage.

[0851] Step 4:

[0852] Using a generative AI model, collected product data is analyzed and normalized into a unified format for language, color, size, etc. Input data: Raw data stored in local storage. Output data: Normalized product information.

[0853] Step 5:

[0854] The server stores the normalized data in a database and searches for products based on the user's registration information. Input data: normalized product data and user characteristic information. Output data: a list of products that match the user's characteristics.

[0855] Step 6:

[0856] Using a generative AI model, we select the products that best suit the user's characteristics and generate a recommendation list. Input data: User characteristics information and product data in the database. Output data: Recommendation list.

[0857] Step 7:

[0858] The server notifies the smartphone app of the generated recommendation list. The user receives the notification and checks the details. Input data: Recommendation list. Output data: Recommended products displayed on the smartphone app.

[0859] Step 8:

[0860] When a user likes a product in the recommendation list and registers it as a "favorite," that information is sent from the application to the server. Input data: Product information registered as a favorite. Output data: Favorite data sent to the server.

[0861] Step 9:

[0862] The server stores the favorite data in a database and uses it to improve the accuracy of recommendations from next time onwards. Input data: Favorite data. Output data: User profile with improved recommendation accuracy from next time onwards.

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

[0864] The present invention relates to a system that allows users to register the characteristics of products they desire and recommends optimal products based on product data collected from multiple e-commerce sites.Furthermore, we will explain in detail an embodiment in which the accuracy of recommendations is improved by combining an emotion engine that recognizes the user's emotions.

[0865] User characteristics registration

[0866] First, the user uses the interface on the device to input the characteristics of the product they want (product name, features, price range, color, etc.). The device receives this information and sends it to the server, which then stores the received characteristic data in a database.

[0867] Collecting and organizing product data

[0868] The server periodically collects product data from multiple e-commerce sites. This process is automated using APIs and web scraping technology. The collected product data is then analyzed using a generative AI model. The AI ​​model normalizes different language notations, colors, sizes, etc. into a unified format. This process ensures that the data in the database is stored in a consistent format.

[0869] Recommendation processing

[0870] Based on the user's registered characteristics, the server searches for product data in the database. Using a generative AI model, it selects the most suitable products, taking into account multidimensional matches (price range, color, size, features, etc.). This generates a list of the best products, which is then sent to the device as a recommendation.

[0871] Use of emotion engine

[0872] The emotion engine recognizes the user's emotional data and provides a means to further adjust the recommendation results based on this. For example, if the user expresses happiness, it will prioritize recommendations of products with positive reviews that match that emotion. Conversely, if the user expresses dissatisfaction, it will suggest problem-solving products that correspond to that emotion.

[0873] Regular recommendation notifications

[0874] Based on the user's settings, the server periodically notifies the device of new recommended products. This notification is sent via the method selected by the user, such as email or in-app notification. The user can then check the details of the recommended products and decide whether to purchase them.

[0875] Register your favorite products and improve the accuracy of your next recommendation

[0876] When a user likes a product in the recommendation list and registers it as a "favorite," the device sends this information to the server. The server stores the favorite data in a database and uses it to improve the accuracy of future recommendations. This mechanism enables the system to provide more personalized recommendations that reflect not only the user's preferences and past tastes, but also their emotional feedback.

[0877] Specific examples

[0878] For example, if a user wants "red sneakers, price range 5,000 to 10,000 yen, size 26cm," they input these characteristics into their terminal and send them to the server. The server generates a list of relevant products based on data collected from e-commerce sites. The generated list includes products such as "red sneakers, price 7,000 yen, size 26cm," which are recommended to the user.

[0879] Furthermore, if the emotion engine analyzes the user's facial expression and detects the emotion of joy, it will prioritize the listing of products with positive reviews that match that emotion.If a user likes "red sneakers, price 7,500 yen, size 26cm" and adds them to their favorites, that information will be reflected in the next recommendation, providing even more accurate results.

[0880] The above is a specific embodiment for implementing the present invention. This system allows users to efficiently find the best products, saving time and effort. Furthermore, the introduction of an emotion engine provides more appropriate recommendations based on the user's emotions.

[0881] The processing flow will be explained below.

[0882] Step 1:

[0883] User enters characteristics

[0884] The user opens the terminal interface and inputs characteristic information such as "product name," "features," "price range," and "color." The terminal temporarily stores this input data and provides a send button. When the user presses the send button, the terminal generates a request to send the input data to the server.

[0885] Step 2:

[0886] The server receives and stores the data

[0887] The server receives the user's input data sent from the device, analyzes the received data, and stores it as a new entry in the database.

[0888] Step 3:

[0889] The server collects product data

[0890] The server periodically collects new product data from multiple e-commerce sites, using APIs and web scraping technology to automatically retrieve product information from each site.

[0891] Step 4:

[0892] Normalization of collected data

[0893] The server uses a generative AI model to analyze the collected product data and normalize it into a unified format, specifically, standardizing language notation, color notation (e.g., brown vs. brown), size notation (e.g., medium vs. regular size), etc.

[0894] Step 5:

[0895] Storing normalized data

[0896] The server stores the normalized product data in a database, which is then used for recommendation processing.

[0897] Step 6:

[0898] Search and select recommended products

[0899] The server searches for products in the database based on the feature data registered by the user, and uses a generative AI model to select the most suitable product, taking into account multidimensional matches (price range, color, size, features, etc.).

[0900] Step 7:

[0901] Generate and send recommendation lists

[0902] The server generates a list of the selected optimal products and sends the generated recommendation list to the device via an API request.

[0903] Step 8:

[0904] Emotion data collection using an emotion engine

[0905] The device collects emotion data from the user's facial expressions and voice, which is then sent to the emotion engine in real time.

[0906] Step 9:

[0907] Recommendation adjustment based on emotional data

[0908] The server analyzes the emotion data sent from the emotion engine and adjusts the recommendation results. For example, if the emotion of joy is detected, it will prioritize products with positive reviews.

[0909] Step 10:

[0910] Display of recommended products

[0911] The terminal displays the recommendation list received from the server on the user interface, allowing the user to check detailed information from this list.

[0912] Step 11:

[0913] Register your favorite products

[0914] The user selects a product from the recommendation list and clicks the "Favorite" button. The device generates a request to send the selected product data to the server.

[0915] Step 12:

[0916] Save and update favorite data

[0917] The server receives the favorite data sent by the user and stores it in a database. The stored data will be used for future recommendation processing.

[0918] Step 13:

[0919] Setting and sending regular recommendation notifications

[0920] The server periodically generates new recommended products based on the user's settings and sends them via the user's preferred notification method (email, in-app notification, etc.).

[0921] These are the specific processing steps of a recommendation service program that incorporates an emotion engine. This series of steps allows users to efficiently find the best products, saving time and effort. Furthermore, the introduction of an emotion engine allows for more appropriate recommendations based on the user's emotions.

[0922] Example 2

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

[0924] Traditional e-commerce systems have difficulty identifying users' desired products and lack personalized recommendation based on their emotions. As a result, users have to spend a lot of time and effort to find suitable products. Furthermore, there is a need for an effective method to normalize collected data, record favorite products, and improve the accuracy of next recommendation.

[0925] The identification process by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes a means for registering the features of products desired by the user, a means for collecting product data from multiple e-commerce sites, a means for normalizing the product data based on the registered features using a generative AI model, a means for recommending optimal products from the normalized product data, a means for collecting user emotion data and reflecting the data in the recommendation results, a means for periodically presenting the recommendation results, and a means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the data. This allows the user to efficiently find optimal products and enables personalized recommendations based on emotions.

[0926] "Users" are ordinary consumers who use the system to search for products and register their characteristics.

[0927] "Features" refers to detailed information about the product desired by the user, specifically including product name, features, price range, color, size, and other conditions.

[0928] "E-commerce site" means a website that offers and allows people to purchase goods over the Internet. Examples include online marketplaces and retailer websites.

[0929] "Product Data" means information about a product collected from an e-commerce site, including details such as price, color, size, manufacturer, and ratings.

[0930] A "generative AI model" is an artificial intelligence model that uses machine learning and deep learning techniques to analyze product data and match it with user characteristics.

[0931] "Normalization" refers to converting collected data into a unified format, including standardization of different language notations, colors, sizes, etc.

[0932] "Recommendation" refers to presenting the most suitable product selected based on the user's characteristics.

[0933] "Emotion data" is information about the emotional state of a user collected from facial expressions, voice, and the like.

[0934] "Favorite products" refers to products that a user has particularly liked and registered, and this data is used to improve the accuracy of recommendations in the future.

[0935] This invention relates to a system that allows users to register the features of products they desire and recommends optimal products based on product data collected from multiple e-commerce sites, and further improves the accuracy of recommendations by combining it with an emotion engine that recognizes the user's emotions.The main components of this system are the user, a terminal, and a server.

[0936] First, the user uses the interface on the device to input the characteristics of the product they want. For example, if the user inputs "red sneakers, price range 5,000 to 10,000 yen, size 26cm," the data is sent from the device to the server. The device can be a typical device such as a smartphone, tablet, or PC. The input data is stored in a database including RAM.

[0937] The server, which is configured using Python or Java, receives feature data sent from devices and stores it in a database. The server also periodically collects product data from multiple e-commerce sites using APIs and web scraping technology. The collected product data is analyzed using a generative AI model (e.g., TensorFlow or PyTorch) to normalize different language notations, colors, sizes, etc. into a unified format. In this process, libraries such as Beautiful Soup and Scrapy are used for web scraping.

[0938] The server then searches for product data in the database based on the user's registered characteristics. Using a generative AI model, it selects the best product by considering multidimensional matches (price range, color, size, features, etc.). For example, if a user enters "red sneakers, price 7,000 yen, size 26cm," it will list products that match those criteria.

[0939] To utilize the emotion engine, the device uses sensors such as a camera and microphone to collect user emotional data. For emotion analysis, OpenCV and dlib libraries are used to analyze the user's facial expressions and voice to determine their emotional state. For example, if the user is smiling and expressing joy, this information is sent to the server, and based on that, products with positive reviews are prioritized for recommendation.

[0940] For periodic recommendation notifications, the server periodically selects new recommended products based on the user's settings and notifies them, for example, by sending emails or in-app notifications to the device using Twilio or Firebase Cloud Messaging.

[0941] Furthermore, when a user registers a product in the recommendation list as a "favorite," that information is sent from the device to the server and stored in a database. This allows this data to be reflected in future recommendations, enabling more personalized recommendations that take into account the user's preferences and emotional feedback.

[0942] Examples of prompts that may be used include:

[0943] "Red sneakers, price range 5,000 to 10,000 yen, size 26cm"

[0944] This system allows users to efficiently find the best products and provides personalized recommendations based on emotions, saving time and effort. In addition, the introduction of an emotion engine provides more appropriate recommendations based on the user's emotions.

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

[0946] Step 1:

[0947] The user inputs the characteristics of the product he or she desires into the terminal.

[0948] How it works: The user accesses the interface on their device and enters detailed information about the product they want (product name, features, price range, color, size, etc.).

[0949] Input: Product feature data entered by the user (e.g., "red sneakers, price range: 5,000 to 10,000 yen, size: 26 cm").

[0950] Output: The input feature data is saved on the device.

[0951] Step 2:

[0952] The terminal sends the input information to the server.

[0953] Operation: The device sends the characteristic data entered by the user to the server according to a protocol (e.g., HTTP POST request).

[0954] Input: The input feature data (e.g., JSON format feature data).

[0955] Output: The server receives the feature data.

[0956] Step 3:

[0957] The server stores the feature data in a database.

[0958] Operation: The server stores the received feature data in a database (e.g., MySQL, PostgreSQL).

[0959] Input: The received feature data (e.g., JSON formatted feature data).

[0960] Output: The feature data is stored in a database.

[0961] Step 4:

[0962] A server collects product data from e-commerce sites.

[0963] How it works: The server uses APIs and web scraping technologies (e.g. Beautiful Soup, Scrapy) to collect product data from multiple e-commerce sites.

[0964] Input: Configuration information for API requests and web scraping.

[0965] Output: Collected product data (e.g. product list in JSON format).

[0966] Step 5:

[0967] The server analyzes and normalizes the collected product data.

[0968] How it works: The server uses generative AI models (e.g., TensorFlow, PyTorch) to analyze collected product data and normalize different language notations, colors, sizes, etc. into a unified format.

[0969] Input: Collected product data (e.g. product list in JSON format).

[0970] Output: Normalized product data (e.g., JSON data in a unified format).

[0971] Step 6:

[0972] The server stores the normalized product data in a database.

[0973] How it works: The server parses and normalizes the product data and stores it in a database.

[0974] Input: Normalized product data (e.g., JSON data in a unified format).

[0975] Output: Normalized product data stored in a database.

[0976] Step 7:

[0977] The server searches for product data in a database.

[0978] Operation: Based on the characteristics registered by the user, the server searches for product data in the database.

[0979] Input: User feature data, product data in the database.

[0980] Output: A list of products that match the user's criteria.

[0981] Step 8:

[0982] A generative AI model selects the best products.

[0983] How it works: The server uses a generative AI model to select the best products, taking into account multi-dimensional matches (price range, color, size, features, etc.).

[0984] Input: Search result product list, generative AI model.

[0985] Output: A list of optimal products (e.g. ranked products).

[0986] Step 9:

[0987] The server sends the recommendation results to the terminal.

[0988] Operation: The selected optimal product list is sent to the device as a recommendation result, and the user can view it on the device.

[0989] Input: Best product list.

[0990] Output: The recommendation results are displayed on the terminal.

[0991] Step 10:

[0992] The device collects the user's emotional data.

[0993] How it works: The device uses sensors such as a camera and microphone to collect emotional data from the user's facial expressions and voice.

[0994] Input: User's facial and voice data.

[0995] Output: Emotion data.

[0996] Step 11:

[0997] The server analyzes the emotion data.

[0998] Operation: The server receives emotion data from the device and performs emotion analysis (e.g., OpenCV, dlib).

[0999] Input: Received emotion data.

[1000] Output: Parsed emotional state.

[1001] Step 12:

[1002] The server adjusts the recommendation results based on emotions.

[1003] How it works: Based on the analysis, the server adjusts the recommendation results. If the user expresses happiness, it prioritizes products with positive reviews.

[1004] Input: Parsed emotional state, recommendation results.

[1005] Output: The refined recommendation results.

[1006] Step 13:

[1007] The server periodically selects new recommended products based on user settings.

[1008] How it works: The server periodically selects new product recommendations based on user settings.

[1009] Input: User settings, latest product data from database.

[1010] Output: The new recommended product list.

[1011] Step 14:

[1012] The server notifies the terminal of recommended products.

[1013] How it works: The server uses Twilio or Firebase Cloud Messaging to notify the device of recommended products via email or in-app notifications.

[1014] Input: A new list of recommended products.

[1015] Output: A recommendation notification will be displayed on the device.

[1016] Step 15:

[1017] The user registers the recommended product as a "favorite."

[1018] How it works: The user selects an item from the recommendation list and adds it to their "favorites."

[1019] Input: Recommendation results, favorite selection operation.

[1020] Output: Favorites data is saved on the device.

[1021] Step 16:

[1022] The device sends the favorites data to the server.

[1023] Operation: The device sends the data registered in "Favorites" to the server.

[1024] Input: Favorites data.

[1025] Output: The server receives the favorites data.

[1026] Step 17:

[1027] The server stores the favorite data in a database and reflects it in the next recommendation.

[1028] How it works: The server stores the received favorite data in a database and uses that information in the next recommendation process.

[1029] Input: Favorites data.

[1030] Output: Favorite data stored in the database, improving the accuracy of next recommendations.

[1031] (Application example 2)

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

[1033] In modern e-commerce, it is difficult for users to quickly and accurately find the features of specific products they desire. Furthermore, typical recommendation systems are unable to take into account individual users' emotions, making it difficult to provide recommendations that fully meet their personal needs. This often leads to a poor user experience and dissatisfaction. Furthermore, it is difficult to unify product data from different e-commerce sites, making it difficult to accurately compare information in multiple languages ​​or with different formats.

[1034] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for registering the features of products desired by the user, means for collecting product data from multiple e-commerce sites, means for normalizing the product data based on the registered features using a generative AI model, means for recommending optimal products from the normalized product data, means for periodically presenting recommendation results, means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the saved data, and means for recognizing the user's emotions using a camera and reflecting the emotions in the recommendation results. This enables accurate product recommendations based on the features of products desired by the user, and personalized recommendations that take the user's emotions into consideration.

[1035] The "means for registering the characteristics of the product desired by the user" is an interface that allows the user to input information such as the name, features, price range, color, and size of the product they want and register it in the system.

[1036] "Means for collecting product data from multiple e-commerce sites" refers to a system that automatically obtains product-related data from multiple e-commerce sites using APIs and web scraping technology.

[1037] "Means for normalizing product data based on registered features using a generative AI model" refers to a function that analyzes acquired product data using a generative AI model and converts different language notations, color notations, size notations, etc. into a unified format.

[1038] The "means for recommending optimal products from normalized product data" is an algorithm that compares the features registered by the user with normalized product data and recommends the product that best matches them.

[1039] The "means for periodically presenting recommendation results" is a method for notifying a user of new recommendation results at regular intervals based on the settings of the registered user.

[1040] "Means of saving data on favorite products and using that data to improve the accuracy of future recommendations" refers to a function that saves information about products registered by users as "favorites" in a database and reflects that information in the recommendation algorithm from the next time onwards.

[1041] "Means of recognizing user emotions using a camera and reflecting them in recommendation results" refers to a technology that uses a camera on a smartphone or head-mounted display to analyze the user's facial expressions and movements, and adjusts the recommendation algorithm based on this emotional information.

[1042] The following describes in detail the embodiments of the present invention. The present invention relates to a system that allows users to register the features of products they desire and recommends optimal products based on product data collected from multiple e-commerce sites. Furthermore, by combining the system with an emotion engine that recognizes user emotions, the accuracy of recommendations can be improved.

[1043] First, the user uses the interface on the device to input the characteristics of the product they want (e.g., product name, features, price range, color, size, etc.). The device receives this information and sends it to the server, which then stores the received characteristic data in a database.

[1044] The server periodically collects product data from multiple e-commerce sites using APIs and web scraping technology. It uses Python's Beautiful Soup library to analyze web pages and extract product data. The collected product data is then analyzed using a generative AI model (e.g., TensorFlow, PyTorch, etc.). This model normalizes different language notations, colors, sizes, and other elements into a unified format.

[1045] Based on the characteristics registered by the user, the server searches for product data in the database, and uses a generative AI model to select the most suitable products, taking into account multidimensional matches such as price range, color, size, and features. This generates a list of the best products, which is then sent to the device as a recommendation result.

[1046] The emotion engine recognizes the user's emotional data using the camera on a smartphone or head-mounted display (HMD). This engine uses OpenCV to analyze the user's facial expressions in real time and read emotions such as joy or dissatisfaction. For example, if the user's emotion of joy is detected, the engine will prioritize recommending products with positive reviews that match that emotion. Conversely, if the user is feeling dissatisfied, it will suggest problem-solving products that correspond to that emotion.

[1047] As a concrete example, if a user desires "red sneakers, price range 5,000 to 10,000 yen, size 26cm," they input these characteristics into their device and send them to the server. The server generates a list of relevant products based on data collected from e-commerce sites. The generated list includes products such as "red sneakers, price 7,000 yen, size 26cm," which are recommended to the user. Furthermore, if the user likes "red sneakers, price 7,500 yen, size 26cm" and registers it as a favorite, this information will be reflected in the next recommendation, providing even more accurate results.

[1048] An example of a prompt for the generative AI model is, "Please normalize the name, price, color, and size of this product into a unified format." This provides users with an efficient way to find the best product, saving time and effort. Furthermore, the introduction of an emotion engine enables more appropriate recommendations based on the user's emotions.

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

[1050] Step 1:

[1051] The user uses the interface on the terminal to input the characteristics of the product they want (e.g., product name, features, price range, color, size, etc.). The input characteristic data is sent from the terminal to the server, which then receives detailed information about the product desired by the user.

[1052] Step 2:

[1053] The server collects product data from multiple e-commerce sites. It uses Python's Beautiful Soup library to perform web scraping and obtain product information (e.g., product name, price, color, size, features, etc.) from these sites. The collected data is stored in the server's database. The input is the URL of the e-commerce site, and the output is the collected product data.

[1054] Step 3:

[1055] The server analyzes the collected product data using a generative AI model and normalizes different language notations, color notations, size notations, etc. into a unified format. TensorFlow and PyTorch are used for the generative AI model. For example, if a color name is written as "red," "red," or "aka," they are unified into a common format: "red." The input is the collected product data, and the output is the normalized product data.

[1056] Step 4:

[1057] The server matches the features registered by the user with normalized product data to select the most suitable products. It uses a generative AI model to check for multidimensional matches such as price range, color, size, and features. Specifically, it compares the user's features with the features of products and lists products with high matching scores. The input is the features registered by the user and normalized product data, and the output is a list of the most suitable products.

[1058] Step 5:

[1059] The server sends the generated optimal product list to the device and presents the recommendation results to the user. The recommendation results are periodically notified to the user via email or in-app notifications. The user receives the notifications and can check detailed information about the recommended products. The input is the optimal product list, and the output is the recommendation notification to the user.

[1060] Step 6:

[1061] The emotion engine recognizes the user's emotions using the camera on a smartphone or head-mounted display (HMD). It uses OpenCV to analyze the user's facial expressions in real time and detect emotions such as joy or displeasure. This emotion data is sent to the server and reflected in the recommendation algorithm. The input is the camera image, and the output is the detected emotion data.

[1062] Step 7:

[1063] The server adjusts the recommendation results based on the user's emotional data and changes the priority of products according to the emotion. For example, if the user expresses joy, it will prioritize products with positive reviews, and if the user expresses dissatisfaction, it will suggest problem-solving products. The input is the emotional data and the optimal product list, and the output is a recommendation list adjusted according to the emotion.

[1064] Step 8:

[1065] Users register their favorite recommended products as "favorites." The device sends this information to the server, which then stores the favorite data in a database. By taking this favorite data into consideration when making recommendations from the next time onward, the accuracy of recommendations can be improved. The input is the information on the favorite products selected by the user, and the output is an updated database.

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

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

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

[1069] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1083] The present invention describes a specific embodiment of a system that allows a user to register the characteristics of a desired product and recommends optimal products based on product data collected from multiple e-commerce sites.

[1084] User characteristics registration

[1085] First, the user uses the interface on the device to input the characteristics of the product they want (e.g., product name, features, price range, color). The device receives this information and sends it to the server, which then stores the received characteristic data in a database.

[1086] Collecting and organizing product data

[1087] The server periodically collects product data from multiple e-commerce sites. This process is automated using APIs and web scraping technology. The collected product data is then analyzed using a generative AI model. The AI ​​model normalizes different language notations, colors, sizes, etc. into a unified format. This process ensures that the data in the database is stored in a consistent format.

[1088] Recommendation processing

[1089] Based on the characteristics registered by the user, the server searches the product data in the database and uses a generative AI model to select candidate products that match various attributes (price range, color, size, features, etc.). This generates an optimal product list and sends it to the device as a recommendation result.

[1090] Regular recommendation notifications

[1091] The server periodically notifies the device of new recommended products based on the user's settings. This notification is sent via the method selected by the user, such as email or in-app notification. The user can then check the details of the recommended products and decide whether to purchase them.

[1092] Register your favorite products and improve the accuracy of your next recommendation

[1093] When a user likes a product in the recommendation list and registers it as a "favorite," the device sends this information to the server. The server stores the favorite data in a database and uses it to improve the accuracy of future recommendations. This mechanism enables the system to provide more personalized recommendations that reflect the user's preferences and past tastes.

[1094] Specific examples

[1095] For example, if a user wants "red sneakers, price range 5,000 to 10,000 yen, size 26cm," they input these characteristics into their device and send them to the server. The server generates a list of relevant products based on data collected from e-commerce sites. The generated list includes products such as "red sneakers, price 7,000 yen, size 26cm," which are recommended to the user. If the user likes "red sneakers, price 7,500 yen, size 26cm" and saves it as a favorite, that information will be reflected in the next recommendation, providing even more accurate results.

[1096] The above is a specific embodiment for carrying out the present invention. This system allows users to efficiently find the most suitable product, saving time and effort.

[1097] The processing flow will be explained below.

[1098] Step 1:

[1099] User enters characteristics

[1100] The user opens the terminal interface and inputs characteristic information such as "product name," "features," "price range," and "color." The terminal temporarily stores this input data and provides a send button. When the user presses the send button, the terminal generates a request to send the input data to the server.

[1101] Step 2:

[1102] The server receives and stores the data

[1103] The server receives the user's input data sent from the device, analyzes the received data, and stores it as a new entry in the database.

[1104] Step 3:

[1105] The server collects product data

[1106] The server periodically collects new product data from multiple e-commerce sites, using APIs and web scraping technology to automatically retrieve product information from each site.

[1107] Step 4:

[1108] Normalization of collected data

[1109] The server uses a generative AI model to analyze the collected product data and normalize it into a unified format, specifically, standardizing language notation, color notation (e.g., brown vs. brown), size notation (e.g., medium vs. regular size), etc.

[1110] Step 5:

[1111] Storing normalized data

[1112] The server stores the normalized product data in a database, which is then used for recommendation processing.

[1113] Step 6:

[1114] Search and select recommended products

[1115] The server searches for products in the database based on the feature data registered by the user, and uses a generative AI model to select the most suitable product, taking into account multidimensional matches (price range, color, size, features, etc.).

[1116] Step 7:

[1117] Generate and send recommendation lists

[1118] The server generates a list of the selected optimal products and sends the generated recommendation list to the device via an API request.

[1119] Step 8:

[1120] Display of recommended products

[1121] The terminal displays the recommendation list received from the server on the user interface, allowing the user to check detailed information from this list.

[1122] Step 9:

[1123] Register your favorite products

[1124] The user selects a product from the recommendation list and clicks the "Favorite" button. The device generates a request to send the selected product data to the server.

[1125] Step 10:

[1126] Save and update favorite data

[1127] The server receives the favorite data sent by the user and stores it in a database. The stored data will be used for future recommendation processing.

[1128] Step 11:

[1129] Setting and sending regular recommendation notifications

[1130] The server periodically generates new recommended products based on the user's settings and sends them via the user's preferred notification method (email, in-app notification, etc.).

[1131] The above are the specific processing steps of a recommendation service program. This series of steps allows users to efficiently find the best products, saving time and effort.

[1132] Example 1

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

[1134] With the development of e-commerce, many products are sold on the Internet. However, it is difficult for users to find the best product from multiple e-commerce sites, and it takes time and effort. Furthermore, existing systems are not accurate enough in providing personalized product recommendations that match the user's preferences. Furthermore, unifying different languages ​​and notations is also an issue. There is a need for a system that can solve these issues and provide users with efficient and accurate product recommendations.

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

[1136] In this invention, the server includes means for registering the features of products desired by a user, means for collecting product data from multiple e-commerce sites, means for normalizing the product data based on the registered features using a generative AI model, means for recommending optimal products from the normalized product data, means for periodically presenting recommendation results, means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the saved data, and means for inputting the data into the generative AI model using prompt sentences. This enables users to efficiently find optimal products based on the features of their desired products and continuously receive highly accurate personalized recommendations.

[1137] "Means for users to register the characteristics of the product they want" refers to a means for users to input the attributes of the product they want (product name, features, price range, color, etc.) and send that information to the server.

[1138] "Means for collecting product data from multiple e-commerce sites" refers to means for automatically collecting product data from multiple e-commerce sites on the Internet using APIs or web scraping tools.

[1139] "Means for normalizing product data based on registered features using a generative AI model" refers to means for using a generative AI model to unify product data written in different notations or formats and convert it into a consistent data format.

[1140] The "means for recommending optimal products from normalized product data" refers to a means for searching a normalized product database for products that best match the characteristics registered by a user and recommending them.

[1141] The "means for periodically presenting recommendation results" is a means for notifying the user of new recommendation results at a frequency designated by the user.

[1142] "Means for saving data on favorite products and improving the accuracy of future recommendations based on that data" refers to a means for saving data on favorite products selected by users from a recommendation list and using that information to improve the accuracy of future recommendations.

[1143] "Means for inputting into a generative AI model using prompt sentences" refers to means for inputting the user's desired product features into a generative AI model as prompt sentences, and then utilizing the model to obtain or process optimal product data.

[1144] This invention describes a specific embodiment of a system that allows a user to register the features of a product they desire and recommends the most suitable product based on product data collected from multiple e-commerce sites.

[1145] First, the user uses the interface on their device (e.g., smartphone or PC) to input the desired product's characteristics (e.g., product name, features, price range, color, etc.). The device then sends this information to the server in JSON format, etc. The server then stores the received characteristic data in a database (e.g., MongoDB or MySQL).

[1146] Next, the server periodically collects product data from multiple e-commerce sites (e.g., general mail-order sites) using APIs or web scraping tools (e.g., BeautifulSoup, Selenium). The collected product data is temporarily stored in JSON format.

[1147] The collected data is analyzed and normalized using a generative AI model (e.g., GPT-3). The server uses this AI model to convert different language notations, color notations, size notations, etc. into a unified format. For example, variations in notations such as "red sneakers" and "Red Sneakers" are unified. This process ensures consistency of the data in the database.

[1148] The server searches for product data in the database based on the characteristics registered by the user. At this time, a generative AI model is used to calculate the degree of match between the user's characteristics and each product attribute (price range, color, size, features, etc.) to generate an optimal product list. For example, if a user registers "red sneakers, price range 5,000 to 10,000 yen, size 26cm," the server will search for products such as "Red Sneakers, Price 7,000 yen, Size 26cm." This list is sent to the user's device as a recommendation result.

[1149] The server periodically notifies the user of the recommendation results and sends them via the user's preferred method (email, in-app notification). Specifically, the server sends a product list along with the message "We have some red sneakers recommended for you!" The user can check this list on their device and access the detail page.

[1150] Furthermore, if a user likes an item in the recommendation list and registers it as a "favorite," the device sends this information to the server. The server saves the favorite data in a database and improves the accuracy of future recommendations. For example, if a user likes "red sneakers, price 7,500 yen, size 26cm" and registers it as a favorite, this information will be reflected in the next recommendation, providing more accurate results.

[1151] Here are some example prompts to input to a generative AI model:

[1152] "The user enters the desired product characteristics. Based on this, search your product database for the best products and generate a list of matching products.

[1153] Features: Red sneakers, price range: 5,000 to 10,000 yen, size 26cm

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

[1155] Step 1:

[1156] The user uses their own device to access a dedicated interface. Through the device's interface, the user inputs the characteristics of the product they want (product name, features, price range, color, etc.). Specifically, they input information such as "red sneakers, price range 5,000 to 10,000 yen, size 26cm." This characteristic data is organized in JSON format and sent to the server. The input data is temporarily saved by sending it to the server.

[1157] Step 2:

[1158] The server parses the feature data sent from the device and stores it in a database. For example, if a database such as MongoDB or MySQL is used, the feature data is converted into an appropriate format and stored in the corresponding table. Through this process, information about the products desired by the user is accumulated in the database.

[1159] Step 3:

[1160] The server periodically collects product data from multiple e-commerce sites using a scheduler (e.g., a Cron job). It obtains the product data using APIs or web scraping technologies such as BeautifulSoup or Selenium. The obtained data is temporarily saved in JSON format. The input of this step is raw data from the e-commerce sites, and the output is JSON data in a unified format.

[1161] Step 4:

[1162] The server inputs the collected product data into a generative AI model (e.g., GPT-3) and normalizes the data. Specifically, it unifies different spellings such as "red sneakers" and "Red Sneakers" to create consistency. The normalized data is stored in a database, and consistent product data is accumulated. The input is raw product data obtained from e-commerce sites, and the output is normalized product data.

[1163] Step 5:

[1164] The server searches for product data in the database based on the feature data registered by the user. At this time, a generative AI model is used to calculate the degree of match between the user's features and each product attribute (price range, color, size, features, etc.) to generate an optimal product list. For example, if a user registers "red sneakers, price range 5,000 to 10,000 yen, size 26cm," the server will search for the product "Red Sneakers, Price 7,000 yen, Size 26cm." The input is the feature data registered by the user, and the output is a list of matching products.

[1165] Step 6:

[1166] The server sends the generated recommendation results to the user's device. This notification is made by the method selected by the user (email, in-app notification, etc.). For example, the server sends a product list with the message "We have some red sneakers recommended for you!" The user can check this list on their device and access the detail page. The input is the generated recommendation results, and the output is the notification sent to the user.

[1167] Step 7:

[1168] Users register their favorite recommended products as "favorites." This information is sent from the device to the server. The server saves the favorite data in a database and improves the accuracy of future recommendations. This process provides more personalized recommendations that reflect the user's past preferences. Specifically, if a user registers "red sneakers, price 7,500 yen, size 26cm" as a favorite, that information will be reflected in the next recommendation. The input is information about the user's "favorite" products, and the output is improved accuracy from the next recommendation onwards.

[1169] (Application example 1)

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

[1171] In e-commerce, it is extremely time-consuming for users to effectively register the characteristics of their desired products and find the optimal product based on product data collected from multiple e-commerce sites. In particular, it is difficult to consistently use data from different sites, which limits the accuracy of efficient product recommendations. Another issue is the difficulty of notifying users of these recommendation results in a timely manner. Therefore, there is a need for a method that allows users to quickly and effectively find the optimal product and encourage them to make a purchase.

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

[1173] In this invention, the server includes means for registering the characteristics of products desired by a user, means for collecting product data from multiple e-commerce sites, means for normalizing the product data based on the registered characteristics using a generative AI model, means for notifying the user of recommendation results via a smartphone app, means for recommending optimal products from the normalized product data, means for periodically presenting the recommendation results, and means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the saved data. This allows users to easily register their desired products, quickly and accurately find optimal products based on data collected from multiple e-commerce sites, and effectively receive notifications via the smartphone app.

[1174] "Means for users to register the characteristics of products they want" is a system in which users input and record information about a specific product (e.g., product name, price range, color, size, etc.).

[1175] The "means for collecting product data from multiple e-commerce sites" is a system that automatically acquires product data from multiple e-commerce sites on the Internet.

[1176] "Generative AI model" is a general term for a model that uses artificial intelligence to analyze and process data, and is used particularly in the present invention for normalizing and recommending product data.

[1177] "Methods for normalizing product data based on characteristics" refers to a technology that converts information written differently into a unified format through intermediate data analysis, ensuring consistency.

[1178] "Means for notifying users of recommendation results via a smartphone app" refers to means for informing users of recommended product information via an application running on a smartphone.

[1179] "Means for recommending optimal products from normalized product data" is a function that selects and recommends products that best suit the user's needs based on data in a standardized format.

[1180] The "means for periodically presenting recommendation results" is a mechanism for providing the latest recommendation information to the user based on a set cycle.

[1181] "Means for saving data on favorite products and using that data to improve the accuracy of future recommendations" refers to a system that records information about products that users have marked as favorites and reflects that data in the next recommendation, thereby providing more accurate recommendations.

[1182] As an embodiment of the present invention, a system is constructed in which a user registers the characteristics of a product they want, and based on those characteristics, the system recommends the most suitable product from multiple e-commerce sites.

[1183] First, the user opens a dedicated application on their smartphone. Through the application's interface, the user inputs the characteristics of the product they want (e.g., product name, price range, color, size, etc.). This information is sent from the application to the server and stored in a database on the server.

[1184] The server then collects product data from multiple e-commerce sites. This is done automatically and periodically using each site's API or web scraping technology. The collected product data is analyzed using a generative AI model and normalized into a unified format, regardless of language, color, or size. This data normalization process ensures that the data in the database is stored in a consistent format.

[1185] Furthermore, the server searches product data in the database based on the characteristics registered by the user. Using a generative AI model, it selects candidate products that match various attributes (price range, color, size, features, etc.). An optimal product list is generated and notified to the user's smartphone as a recommendation result.

[1186] The server periodically notifies the smartphone app of new recommended products based on the user's settings. This notification is sent via the method selected by the user, such as in-app notification or email. The user can then check the details of the recommended products and decide whether to purchase them.

[1187] Furthermore, if a user likes a product in the recommendation list and registers it as a "favorite," the application sends this information to the server. The server then stores the favorite data in a database and uses it to improve the accuracy of future recommendations. This mechanism enables the system to provide more personalized recommendations that reflect the user's preferences and past tastes.

[1188] As a concrete example, suppose a user inputs the characteristics of "red sneakers, price range 5,000 to 10,000 yen, size 26cm." This information is sent to the server, and corresponding products are listed based on collected data from e-commerce sites. For example, a product such as "red sneakers, price 7,000 yen, size 26cm" may be recommended. If the user likes this product and registers it as a "favorite," that information will be reflected in the next recommendation.

[1189] An example of a prompt is as follows:

[1190] The user enters the characteristics of the product they want: red sneakers, price range 5,000 to 10,000 yen, size 26cm.

[1191] Collect product data from the following e-commerce sites: site1.com / api / products, site2.com / api / products.

[1192] Analyze and normalize the collected data to recommend matching products.

[1193] The hardware used includes smartphones, cloud servers (e.g., AWS, GCP), databases (e.g., MySQL, PostgreSQL), and software using generative AI models (e.g., GPT series). In this way, users can efficiently find the best products, saving time and effort.

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

[1195] Step 1:

[1196] The user opens the application on their smartphone and enters the characteristics of the product they want (e.g. product name, price range, color, size, etc.). The entered data is sent to the server as a JSON format object. Input data: Product characteristic information entered by the user. Output data: User information in JSON format sent to the server.

[1197] Step 2:

[1198] The server stores the received user feature data in a database. Input data: User information in JSON format. Output data: User information stored in the database.

[1199] Step 3:

[1200] The server periodically collects product data using APIs and web scraping technology from e-commerce sites. The collected data is temporarily stored in local storage. Input data: Product data obtained from each e-commerce site. Output data: Product data stored in local storage.

[1201] Step 4:

[1202] Using a generative AI model, collected product data is analyzed and normalized into a unified format for language, color, size, etc. Input data: Raw data stored in local storage. Output data: Normalized product information.

[1203] Step 5:

[1204] The server stores the normalized data in a database and searches for products based on the user's registration information. Input data: normalized product data and user characteristic information. Output data: a list of products that match the user's characteristics.

[1205] Step 6:

[1206] Using a generative AI model, we select the products that best suit the user's characteristics and generate a recommendation list. Input data: User characteristics information and product data in the database. Output data: Recommendation list.

[1207] Step 7:

[1208] The server notifies the smartphone app of the generated recommendation list. The user receives the notification and checks the details. Input data: Recommendation list. Output data: Recommended products displayed on the smartphone app.

[1209] Step 8:

[1210] When a user likes a product in the recommendation list and registers it as a "favorite," that information is sent from the application to the server. Input data: Product information registered as a favorite. Output data: Favorite data sent to the server.

[1211] Step 9:

[1212] The server stores the favorite data in a database and uses it to improve the accuracy of recommendations from next time onwards. Input data: Favorite data. Output data: User profile with improved recommendation accuracy from next time onwards.

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

[1214] The present invention relates to a system that allows users to register the characteristics of products they desire and recommends optimal products based on product data collected from multiple e-commerce sites.Furthermore, we will explain in detail an embodiment in which the accuracy of recommendations is improved by combining an emotion engine that recognizes the user's emotions.

[1215] User characteristics registration

[1216] First, the user uses the interface on the device to input the characteristics of the product they want (product name, features, price range, color, etc.). The device receives this information and sends it to the server, which then stores the received characteristic data in a database.

[1217] Collecting and organizing product data

[1218] The server periodically collects product data from multiple e-commerce sites. This process is automated using APIs and web scraping technology. The collected product data is then analyzed using a generative AI model. The AI ​​model normalizes different language notations, colors, sizes, etc. into a unified format. This process ensures that the data in the database is stored in a consistent format.

[1219] Recommendation processing

[1220] Based on the user's registered characteristics, the server searches for product data in the database. Using a generative AI model, it selects the most suitable products, taking into account multidimensional matches (price range, color, size, features, etc.). This generates a list of the best products, which is then sent to the device as a recommendation.

[1221] Use of emotion engine

[1222] The emotion engine recognizes the user's emotional data and provides a means to further adjust the recommendation results based on this. For example, if the user expresses happiness, it will prioritize recommendations of products with positive reviews that match that emotion. Conversely, if the user expresses dissatisfaction, it will suggest problem-solving products that correspond to that emotion.

[1223] Regular recommendation notifications

[1224] Based on the user's settings, the server periodically notifies the device of new recommended products. This notification is sent via the method selected by the user, such as email or in-app notification. The user can then check the details of the recommended products and decide whether to purchase them.

[1225] Register your favorite products and improve the accuracy of your next recommendation

[1226] When a user likes a product in the recommendation list and registers it as a "favorite," the device sends this information to the server. The server stores the favorite data in a database and uses it to improve the accuracy of future recommendations. This mechanism enables the system to provide more personalized recommendations that reflect not only the user's preferences and past tastes, but also their emotional feedback.

[1227] Specific examples

[1228] For example, if a user wants "red sneakers, price range 5,000 to 10,000 yen, size 26cm," they input these characteristics into their terminal and send them to the server. The server generates a list of relevant products based on data collected from e-commerce sites. The generated list includes products such as "red sneakers, price 7,000 yen, size 26cm," which are recommended to the user.

[1229] Furthermore, if the emotion engine analyzes the user's facial expression and detects the emotion of joy, it will prioritize the listing of products with positive reviews that match that emotion.If a user likes "red sneakers, price 7,500 yen, size 26cm" and adds them to their favorites, that information will be reflected in the next recommendation, providing even more accurate results.

[1230] The above is a specific embodiment for implementing the present invention. This system allows users to efficiently find the best products, saving time and effort. Furthermore, the introduction of an emotion engine provides more appropriate recommendations based on the user's emotions.

[1231] The processing flow will be explained below.

[1232] Step 1:

[1233] User enters characteristics

[1234] The user opens the terminal interface and inputs characteristic information such as "product name," "features," "price range," and "color." The terminal temporarily stores this input data and provides a send button. When the user presses the send button, the terminal generates a request to send the input data to the server.

[1235] Step 2:

[1236] The server receives and stores the data

[1237] The server receives the user's input data sent from the device, analyzes the received data, and stores it as a new entry in the database.

[1238] Step 3:

[1239] The server collects product data

[1240] The server periodically collects new product data from multiple e-commerce sites, using APIs and web scraping technology to automatically retrieve product information from each site.

[1241] Step 4:

[1242] Normalization of collected data

[1243] The server uses a generative AI model to analyze the collected product data and normalize it into a unified format, specifically, standardizing language notation, color notation (e.g., brown vs. brown), size notation (e.g., medium vs. regular size), etc.

[1244] Step 5:

[1245] Storing normalized data

[1246] The server stores the normalized product data in a database, which is then used for recommendation processing.

[1247] Step 6:

[1248] Search and select recommended products

[1249] The server searches for products in the database based on the feature data registered by the user, and uses a generative AI model to select the most suitable product, taking into account multidimensional matches (price range, color, size, features, etc.).

[1250] Step 7:

[1251] Generate and send recommendation lists

[1252] The server generates a list of the selected optimal products and sends the generated recommendation list to the device via an API request.

[1253] Step 8:

[1254] Emotion data collection using an emotion engine

[1255] The device collects emotion data from the user's facial expressions and voice, which is then sent to the emotion engine in real time.

[1256] Step 9:

[1257] Recommendation adjustment based on emotional data

[1258] The server analyzes the emotion data sent from the emotion engine and adjusts the recommendation results. For example, if the emotion of joy is detected, it will prioritize products with positive reviews.

[1259] Step 10:

[1260] Display of recommended products

[1261] The terminal displays the recommendation list received from the server on the user interface, allowing the user to check detailed information from this list.

[1262] Step 11:

[1263] Register your favorite products

[1264] The user selects a product from the recommendation list and clicks the "Favorite" button. The device generates a request to send the selected product data to the server.

[1265] Step 12:

[1266] Save and update favorite data

[1267] The server receives the favorite data sent by the user and stores it in a database. The stored data will be used for future recommendation processing.

[1268] Step 13:

[1269] Setting and sending regular recommendation notifications

[1270] The server periodically generates new recommended products based on the user's settings and sends them via the user's preferred notification method (email, in-app notification, etc.).

[1271] These are the specific processing steps of a recommendation service program that incorporates an emotion engine. This series of steps allows users to efficiently find the best products, saving time and effort. Furthermore, the introduction of an emotion engine allows for more appropriate recommendations based on the user's emotions.

[1272] Example 2

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

[1274] Traditional e-commerce systems have difficulty identifying users' desired products and lack personalized recommendation based on their emotions. As a result, users have to spend a lot of time and effort to find suitable products. Furthermore, there is a need for an effective method to normalize collected data, record favorite products, and improve the accuracy of next recommendation.

[1275] The identification process by the identification processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes a means for registering the features of products desired by the user, a means for collecting product data from multiple e-commerce sites, a means for normalizing the product data based on the registered features using a generative AI model, a means for recommending optimal products from the normalized product data, a means for collecting user emotion data and reflecting the data in the recommendation results, a means for periodically presenting the recommendation results, and a means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the data. This allows the user to efficiently find optimal products and enables personalized recommendations based on emotions.

[1276] "Users" are ordinary consumers who use the system to search for products and register their characteristics.

[1277] "Features" refers to detailed information about the product desired by the user, specifically including product name, features, price range, color, size, and other conditions.

[1278] "E-commerce site" means a website that offers and allows people to purchase goods over the Internet. Examples include online marketplaces and retailer websites.

[1279] "Product Data" means information about a product collected from an e-commerce site, including details such as price, color, size, manufacturer, and ratings.

[1280] A "generative AI model" is an artificial intelligence model that uses machine learning and deep learning techniques to analyze product data and match it with user characteristics.

[1281] "Normalization" refers to converting collected data into a unified format, including standardization of different language notations, colors, sizes, etc.

[1282] "Recommendation" refers to presenting the most suitable product selected based on the user's characteristics.

[1283] "Emotion data" is information about the emotional state of a user collected from facial expressions, voice, and the like.

[1284] "Favorite products" refers to products that a user has particularly liked and registered, and this data is used to improve the accuracy of recommendations in the future.

[1285] This invention relates to a system that allows users to register the features of products they desire and recommends optimal products based on product data collected from multiple e-commerce sites, and further improves the accuracy of recommendations by combining it with an emotion engine that recognizes the user's emotions.The main components of this system are the user, a terminal, and a server.

[1286] First, the user uses the interface on the device to input the characteristics of the product they want. For example, if the user inputs "red sneakers, price range 5,000 to 10,000 yen, size 26cm," the data is sent from the device to the server. The device can be a typical device such as a smartphone, tablet, or PC. The input data is stored in a database including RAM.

[1287] The server, which is configured using Python or Java, receives feature data sent from devices and stores it in a database. The server also periodically collects product data from multiple e-commerce sites using APIs and web scraping technology. The collected product data is analyzed using a generative AI model (e.g., TensorFlow or PyTorch) to normalize different language notations, colors, sizes, etc. into a unified format. In this process, libraries such as Beautiful Soup and Scrapy are used for web scraping.

[1288] The server then searches for product data in the database based on the user's registered characteristics. Using a generative AI model, it selects the best product by considering multidimensional matches (price range, color, size, features, etc.). For example, if a user enters "red sneakers, price 7,000 yen, size 26cm," it will list products that match those criteria.

[1289] To utilize the emotion engine, the device uses sensors such as a camera and microphone to collect user emotional data. For emotion analysis, OpenCV and dlib libraries are used to analyze the user's facial expressions and voice to determine their emotional state. For example, if the user is smiling and expressing joy, this information is sent to the server, and based on that, products with positive reviews are prioritized for recommendation.

[1290] For periodic recommendation notifications, the server periodically selects new recommended products based on the user's settings and notifies them, for example, by sending emails or in-app notifications to the device using Twilio or Firebase Cloud Messaging.

[1291] Furthermore, when a user registers a product in the recommendation list as a "favorite," that information is sent from the device to the server and stored in a database. This allows this data to be reflected in future recommendations, enabling more personalized recommendations that take into account the user's preferences and emotional feedback.

[1292] Examples of prompts that may be used include:

[1293] "Red sneakers, price range 5,000 to 10,000 yen, size 26cm"

[1294] This system allows users to efficiently find the best products and provides personalized recommendations based on emotions, saving time and effort. In addition, the introduction of an emotion engine provides more appropriate recommendations based on the user's emotions.

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

[1296] Step 1:

[1297] The user inputs the characteristics of the product he or she desires into the terminal.

[1298] How it works: The user accesses the interface on their device and enters detailed information about the product they want (product name, features, price range, color, size, etc.).

[1299] Input: Product feature data entered by the user (e.g., "red sneakers, price range: 5,000 to 10,000 yen, size: 26 cm").

[1300] Output: The input feature data is saved on the device.

[1301] Step 2:

[1302] The terminal sends the input information to the server.

[1303] Operation: The device sends the characteristic data entered by the user to the server according to a protocol (e.g., HTTP POST request).

[1304] Input: The input feature data (e.g., JSON format feature data).

[1305] Output: The server receives the feature data.

[1306] Step 3:

[1307] The server stores the feature data in a database.

[1308] Operation: The server stores the received feature data in a database (e.g., MySQL, PostgreSQL).

[1309] Input: The received feature data (e.g., JSON formatted feature data).

[1310] Output: The feature data is stored in a database.

[1311] Step 4:

[1312] A server collects product data from e-commerce sites.

[1313] How it works: The server uses APIs and web scraping technologies (e.g. Beautiful Soup, Scrapy) to collect product data from multiple e-commerce sites.

[1314] Input: Configuration information for API requests and web scraping.

[1315] Output: Collected product data (e.g. product list in JSON format).

[1316] Step 5:

[1317] The server analyzes and normalizes the collected product data.

[1318] How it works: The server uses generative AI models (e.g., TensorFlow, PyTorch) to analyze collected product data and normalize different language notations, colors, sizes, etc. into a unified format.

[1319] Input: Collected product data (e.g. product list in JSON format).

[1320] Output: Normalized product data (e.g., JSON data in a unified format).

[1321] Step 6:

[1322] The server stores the normalized product data in a database.

[1323] How it works: The server parses and normalizes the product data and stores it in a database.

[1324] Input: Normalized product data (e.g., JSON data in a unified format).

[1325] Output: Normalized product data stored in a database.

[1326] Step 7:

[1327] The server searches for product data in a database.

[1328] Operation: Based on the characteristics registered by the user, the server searches for product data in the database.

[1329] Input: User feature data, product data in the database.

[1330] Output: A list of products that match the user's criteria.

[1331] Step 8:

[1332] A generative AI model selects the best products.

[1333] How it works: The server uses a generative AI model to select the best products, taking into account multi-dimensional matches (price range, color, size, features, etc.).

[1334] Input: Search result product list, generative AI model.

[1335] Output: A list of optimal products (e.g. ranked products).

[1336] Step 9:

[1337] The server sends the recommendation results to the terminal.

[1338] Operation: The selected optimal product list is sent to the device as a recommendation result, and the user can view it on the device.

[1339] Input: Best product list.

[1340] Output: The recommendation results are displayed on the terminal.

[1341] Step 10:

[1342] The device collects the user's emotional data.

[1343] How it works: The device uses sensors such as a camera and microphone to collect emotional data from the user's facial expressions and voice.

[1344] Input: User's facial and voice data.

[1345] Output: Emotion data.

[1346] Step 11:

[1347] The server analyzes the emotion data.

[1348] Operation: The server receives emotion data from the device and performs emotion analysis (e.g., OpenCV, dlib).

[1349] Input: Received emotion data.

[1350] Output: Parsed emotional state.

[1351] Step 12:

[1352] The server adjusts the recommendation results based on emotions.

[1353] How it works: Based on the analysis, the server adjusts the recommendation results. If the user expresses happiness, it prioritizes products with positive reviews.

[1354] Input: Parsed emotional state, recommendation results.

[1355] Output: The refined recommendation results.

[1356] Step 13:

[1357] The server periodically selects new recommended products based on user settings.

[1358] How it works: The server periodically selects new product recommendations based on user settings.

[1359] Input: User settings, latest product data from database.

[1360] Output: The new recommended product list.

[1361] Step 14:

[1362] The server notifies the terminal of recommended products.

[1363] How it works: The server uses Twilio or Firebase Cloud Messaging to notify the device of recommended products via email or in-app notifications.

[1364] Input: A new list of recommended products.

[1365] Output: A recommendation notification will be displayed on the device.

[1366] Step 15:

[1367] The user registers the recommended product as a "favorite."

[1368] How it works: The user selects an item from the recommendation list and adds it to their "favorites."

[1369] Input: Recommendation results, favorite selection operation.

[1370] Output: Favorites data is saved on the device.

[1371] Step 16:

[1372] The device sends the favorites data to the server.

[1373] Operation: The device sends the data registered in "Favorites" to the server.

[1374] Input: Favorites data.

[1375] Output: The server receives the favorites data.

[1376] Step 17:

[1377] The server stores the favorite data in a database and reflects it in the next recommendation.

[1378] How it works: The server stores the received favorite data in a database and uses that information in the next recommendation process.

[1379] Input: Favorites data.

[1380] Output: Favorite data stored in the database, improving the accuracy of next recommendations.

[1381] (Application example 2)

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

[1383] In modern e-commerce, it is difficult for users to quickly and accurately find the features of specific products they desire. Furthermore, typical recommendation systems are unable to take into account individual users' emotions, making it difficult to provide recommendations that fully meet their personal needs. This often leads to a poor user experience and dissatisfaction. Furthermore, it is difficult to unify product data from different e-commerce sites, making it difficult to accurately compare information in multiple languages ​​or with different formats.

[1384] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for registering the features of products desired by the user, means for collecting product data from multiple e-commerce sites, means for normalizing the product data based on the registered features using a generative AI model, means for recommending optimal products from the normalized product data, means for periodically presenting recommendation results, means for saving data on favorite products and improving the accuracy of subsequent recommendations based on the saved data, and means for recognizing the user's emotions using a camera and reflecting the emotions in the recommendation results. This enables accurate product recommendations based on the features of products desired by the user, and personalized recommendations that take the user's emotions into consideration.

[1385] The "means for registering the characteristics of the product desired by the user" is an interface that allows the user to input information such as the name, features, price range, color, and size of the product they want and register it in the system.

[1386] "Means for collecting product data from multiple e-commerce sites" refers to a system that automatically obtains product-related data from multiple e-commerce sites using APIs and web scraping technology.

[1387] "Means for normalizing product data based on registered features using a generative AI model" refers to a function that analyzes acquired product data using a generative AI model and converts different language notations, color notations, size notations, etc. into a unified format.

[1388] The "means for recommending optimal products from normalized product data" is an algorithm that compares the features registered by the user with normalized product data and recommends the product that best matches them.

[1389] The "means for periodically presenting recommendation results" is a method for notifying a user of new recommendation results at regular intervals based on the settings of the registered user.

[1390] "Means of saving data on favorite products and using that data to improve the accuracy of future recommendations" refers to a function that saves information about products registered by users as "favorites" in a database and reflects that information in the recommendation algorithm from the next time onwards.

[1391] "Means of recognizing user emotions using a camera and reflecting them in recommendation results" refers to a technology that uses a camera on a smartphone or head-mounted display to analyze the user's facial expressions and movements, and adjusts the recommendation algorithm based on this emotional information.

[1392] The following describes in detail the embodiments of the present invention. The present invention relates to a system that allows users to register the features of products they desire and recommends optimal products based on product data collected from multiple e-commerce sites. Furthermore, by combining the system with an emotion engine that recognizes user emotions, the accuracy of recommendations can be improved.

[1393] First, the user uses the interface on the device to input the characteristics of the product they want (e.g., product name, features, price range, color, size, etc.). The device receives this information and sends it to the server, which then stores the received characteristic data in a database.

[1394] The server periodically collects product data from multiple e-commerce sites using APIs and web scraping technology. It uses Python's Beautiful Soup library to analyze web pages and extract product data. The collected product data is then analyzed using a generative AI model (e.g., TensorFlow, PyTorch, etc.). This model normalizes different language notations, colors, sizes, and other elements into a unified format.

[1395] Based on the characteristics registered by the user, the server searches for product data in the database, and uses a generative AI model to select the most suitable products, taking into account multidimensional matches such as price range, color, size, and features. This generates a list of the best products, which is then sent to the device as a recommendation result.

[1396] The emotion engine recognizes the user's emotional data using the camera on a smartphone or head-mounted display (HMD). This engine uses OpenCV to analyze the user's facial expressions in real time and read emotions such as joy or dissatisfaction. For example, if the user's emotion of joy is detected, the engine will prioritize recommending products with positive reviews that match that emotion. Conversely, if the user is feeling dissatisfied, it will suggest problem-solving products that correspond to that emotion.

[1397] As a concrete example, if a user desires "red sneakers, price range 5,000 to 10,000 yen, size 26cm," they input these characteristics into their device and send them to the server. The server generates a list of relevant products based on data collected from e-commerce sites. The generated list includes products such as "red sneakers, price 7,000 yen, size 26cm," which are recommended to the user. Furthermore, if the user likes "red sneakers, price 7,500 yen, size 26cm" and registers it as a favorite, this information will be reflected in the next recommendation, providing even more accurate results.

[1398] An example of a prompt for the generative AI model is, "Please normalize the name, price, color, and size of this product into a unified format." This provides users with an efficient way to find the best product, saving time and effort. Furthermore, the introduction of an emotion engine enables more appropriate recommendations based on the user's emotions.

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

[1400] Step 1:

[1401] The user uses the interface on the terminal to input the characteristics of the product they want (e.g., product name, features, price range, color, size, etc.). The input characteristic data is sent from the terminal to the server, which then receives detailed information about the product desired by the user.

[1402] Step 2:

[1403] The server collects product data from multiple e-commerce sites. It uses Python's Beautiful Soup library to perform web scraping and obtain product information (e.g., product name, price, color, size, features, etc.) from these sites. The collected data is stored in the server's database. The input is the URL of the e-commerce site, and the output is the collected product data.

[1404] Step 3:

[1405] The server analyzes the collected product data using a generative AI model and normalizes different language notations, color notations, size notations, etc. into a unified format. TensorFlow and PyTorch are used for the generative AI model. For example, if a color name is written as "red," "red," or "aka," they are unified into a common format: "red." The input is the collected product data, and the output is the normalized product data.

[1406] Step 4:

[1407] The server matches the features registered by the user with normalized product data to select the most suitable products. It uses a generative AI model to check for multidimensional matches such as price range, color, size, and features. Specifically, it compares the user's features with the features of products and lists products with high matching scores. The input is the features registered by the user and normalized product data, and the output is a list of the most suitable products.

[1408] Step 5:

[1409] The server sends the generated optimal product list to the device and presents the recommendation results to the user. The recommendation results are periodically notified to the user via email or in-app notifications. The user receives the notifications and can check detailed information about the recommended products. The input is the optimal product list, and the output is the recommendation notification to the user.

[1410] Step 6:

[1411] The emotion engine recognizes the user's emotions using the camera on a smartphone or head-mounted display (HMD). It uses OpenCV to analyze the user's facial expressions in real time and detect emotions such as joy or displeasure. This emotion data is sent to the server and reflected in the recommendation algorithm. The input is the camera image, and the output is the detected emotion data.

[1412] Step 7:

[1413] The server adjusts the recommendation results based on the user's emotional data and changes the priority of products according to the emotion. For example, if the user expresses joy, it will prioritize products with positive reviews, and if the user expresses dissatisfaction, it will suggest problem-solving products. The input is the emotional data and the optimal product list, and the output is a recommendation list adjusted according to the emotion.

[1414] Step 8:

[1415] Users register their favorite recommended products as "favorites." The device sends this information to the server, which then stores the favorite data in a database. By taking this favorite data into consideration when making recommendations from the next time onward, the accuracy of recommendations can be improved. The input is the information on the favorite products selected by the user, and the output is an updated database.

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

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

[1418] 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 robot 414.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[1437] The following is further disclosed regarding the above embodiment.

[1438] (Claim 1)

[1439] A means for users to register the features of the products they want;

[1440] a means for collecting product data from multiple e-commerce sites;

[1441] A means for normalizing product data based on registered features using a generative AI model; and

[1442] A method for recommending optimal products from normalized product data,

[1443] A means for periodically presenting recommendation results;

[1444] It is a way to save data on favorite products and improve the accuracy of future recommendations based on that data.

[1445] A system including:

[1446] (Claim 2)

[1447] A means to save product data registered in favorites by users and reflect it in recommendation results.

[1448] The system of claim 1 further comprising:

[1449] (Claim 3)

[1450] A means of unifying different language notations, colors, and sizes using generative AI models.

[1451] The system of claim 1 further comprising:

[1452] "Example 1"

[1453] (Claim 1)

[1454] A means for users to register the features of the products they want;

[1455] a means for collecting product data from multiple e-commerce sites;

[1456] A means for normalizing product data based on registered features using a generative AI model; and

[1457] A method for recommending optimal products from normalized product data,

[1458] A means for periodically presenting recommendation results;

[1459] A method to save data on favorite products and improve the accuracy of future recommendations based on that data.

[1460] means for inputting the generative AI model using prompt sentences;

[1461] A system including:

[1462] (Claim 2)

[1463] A means to save product data registered in favorites by users and reflect it in recommendation results.

[1464] The system of claim 1 further comprising:

[1465] (Claim 3)

[1466] A means of unifying different language notations, colors, and sizes using generative AI models.

[1467] The system of claim 1 further comprising:

[1468] "Application Example 1"

[1469] (Claim 1)

[1470] A means for users to register the features of the products they want;

[1471] a means for collecting product data from multiple e-commerce sites;

[1472] A means for normalizing product data based on registered features using a generative AI model; and

[1473] A means for notifying the user of the recommendation results via a smartphone app;

[1474] A method for recommending optimal products from normalized product data,

[1475] A means for periodically presenting recommendation results;

[1476] It is a way to save data on favorite products and improve the accuracy of future recommendations based on that data.

[1477] A system including:

[1478] (Claim 2)

[1479] A means for saving product data registered as favorites by a user and reflecting the data in recommendation results;

[1480] A means of sending product notifications on smartphones

[1481] The system of claim 1 further comprising:

[1482] (Claim 3)

[1483] A means to unify different language notations, color notations, and size notations using generative AI models,

[1484] A method for normalizing data obtained from websites and displaying it on smartphone apps.

[1485] The system of claim 1 further comprising:

[1486] "Example 2: Combining Emotion Engines"

[1487] (Claim 1)

[1488] A means for users to register the features of the products they want;

[1489] a means for collecting product data from multiple e-commerce sites;

[1490] A means for normalizing product data based on registered features using a generative AI model; and

[1491] A method for recommending optimal products from normalized product data,

[1492] A means for collecting user emotion data and reflecting it in recommendation results;

[1493] A means for periodically presenting recommendation results;

[1494] It is a way to save data on favorite products and improve the accuracy of future recommendations based on that data.

[1495] A system including:

[1496] (Claim 2)

[1497] A means to save product data registered in favorites by users and reflect it in recommendation results.

[1498] The system of claim 1 further comprising:

[1499] (Claim 3)

[1500] A means of unifying different language notations, colors, and sizes using generative AI models.

[1501] The system of claim 1 further comprising:

[1502] "Application example 2 when combining emotion engines"

[1503] (Claim 1)

[1504] A means for users to register the features of the products they want;

[1505] a means for collecting product data from multiple e-commerce sites;

[1506] A means for normalizing product data based on registered features using a generative AI model; and

[1507] A method for recommending optimal products from normalized product data,

[1508] A means for periodically presenting recommendation results;

[1509] A method to save data on favorite products and improve the accuracy of future recommendations based on that data.

[1510] A means for recognizing user emotions using a camera and reflecting them in recommendation results;

[1511] A system including:

[1512] (Claim 2)

[1513] A means to save product data registered in favorites by users and reflect it in recommendation results.

[1514] A means of unifying different language notations, colors, and sizes using generative AI models.

[1515] The system of claim 1 further comprising:

[1516] (Claim 3)

[1517] A means of analyzing and normalizing product data collected from multiple e-commerce sites using generative AI models.

[1518] It uses a camera to recognize the user's emotions in real time and displays recommendations based on those emotions.

[1519] The system of claim 1 further comprising: [Explanation of symbols]

[1520] 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 for users to register the features of the products they want; a means for collecting product data from multiple e-commerce sites; A means for normalizing product data based on registered features using a generative AI model; and A method for recommending optimal products from normalized product data, A means for periodically presenting recommendation results; It is a way to save data on favorite products and improve the accuracy of future recommendations based on that data. A system including:

2. A means to save product data registered in favorites by users and reflect it in recommendation results. The system of claim 1 further comprising:

3. A means of unifying different language notations, colors, and sizes using generative AI models. The system of claim 1 further comprising:

Images