system

Abstract

Provide a system. A system for generating individual fashion images based on conditions input by a user, comprising: means for receiving conditions input by the user to the terminal; A means for generating a fashion image using a generation AI based on the conditions; means for returning the generated fashion image to the terminal; A system including:

Description

[Technical Field]

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

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

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

[0004] Conventional fashion item search systems have the problem of making it difficult to find products that perfectly match an individual's specific preferences and image. Furthermore, users often need a lot of time and effort to visualize their specific image. Furthermore, when searching for items based on a specific theme or style, there is a problem in that there are limited means to verify whether the item truly matches the user's desires. There is a need to solve these problems and quickly and accurately provide customized fashion images that meet the user's needs. [Means for solving the problem]

[0005] The present invention provides a system that uses generative AI to generate individual fashion images based on user input conditions. Specifically, the system includes a means for receiving conditions entered by the user into a terminal, a means for generating fashion images using generative AI based on the conditions, and a means for returning the generated images to the terminal. This allows users to easily obtain visual images that match their specific fashion preferences, significantly reducing search efforts. Furthermore, the use of generative AI makes it possible to generate item designs based on the user's detailed requests and themes, resulting in customized fashion suggestions.

[0006] 1. "User" refers to any individual or organization that uses this system.

[0007] 2. "Terminal" refers to an electronic device, such as a smartphone, PC, or tablet, that allows a user to input and receive information.

[0008] 3. "Conditions" refers to input information that describes a user's preferences or desires regarding a particular fashion item.

[0009] 4. "Generative AI" refers to the part of the system that uses artificial intelligence technology to automatically generate fashion images based on user criteria.

[0010] 5. "Server" refers to a computer system, including a generation AI, that receives requests from a terminal, processes them, and returns a response.

[0011] 6. “Image” refers to the visual representation of a fashion item created by generative AI.

[0012] 7. "Metadata" refers to additional information associated with a generated image (e.g., size, color, material, etc.).

[0013] 8. "HTTP request" refers to a request message based on a communication protocol for requesting information from a terminal to a server.

[0014] 9. "HTTP response" refers to a response message based on a communication protocol that allows a server to return information to a terminal.

[0015] 10. "Format" refers to the process of putting data into a certain form. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0024] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0037] This invention relates to a system that uses generative AI to generate fashion images based on conditions entered by a user. This system is composed of elements including a user, a terminal, and a server, and is described in detail below.

[0038] System configuration

[0039] The system includes the following major components:

[0040] 1. User: An individual who wants to embody the image of a fashion item.

[0041] 2. Device: Electronic devices used by users, such as smartphones, computers, and tablets.

[0042] 3. Server: A computer system that includes a generation AI and receives user requests and performs image generation.

[0043] Program Processing Overview

[0044] Users input the specifications for the fashion items they are looking for through their device, and this information is sent to the server. The server uses generative AI to generate fashion images based on the received specifications and sends the results back to the device. This allows users to obtain specific visuals of the fashion items they desire.

[0045] Program Processing Details

[0046] User Input

[0047] Users open a dedicated interface on their device and enter the desired fashion items, such as "adult T-shirts" or "Pokémon-style sneakers." Once the input is complete, the data is sent by clicking the "Send" button.

[0048] Input data formatting and transmission

[0049] The device parses the user's input data, converts it into an appropriate format (e.g., JSON), and sends it to the server as an HTTP POST request.

[0050] Data reception and analysis on the server

[0051] The server receives the request sent from the device and analyzes the input data. Conditions are extracted from the analyzed data and prepared for passing to the generation AI.

[0052] Image generation by generative AI

[0053] The server passes the analysis results to the generation AI as input data. Based on this, the generation AI generates fashion images that match the conditions. The generation AI uses past data and learning models to create the optimal image.

[0054] Returning images

[0055] The generated fashion image and associated metadata (e.g., size, color, and material information) are sent back to the terminal as an HTTP response from the server.

[0056] Displaying an image to the user

[0057] The device analyzes the image data received from the server and displays it to the user, who can then view the image and save or share it as needed.

[0058] Specific use cases

[0059] Example 1: Generating images of adult T-shirts

[0060] 1. The user enters "adult T-shirt" into the device interface and presses the "Send" button.

[0061] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[0062] 3. The server receives this request and passes the condition "adult T-shirt" to the generation AI.

[0063] 4. The generative AI generates an image of a T-shirt with a simple yet sophisticated design and sends it back to the server.

[0064] 5. The server sends the generated image back to the device.

[0065] 6. The terminal displays the received image to the user, who confirms it.

[0066] Example 2: Image generation of Pokémon-style sneakers

[0067] 1. The user types "Pokémon-style sneakers" into the device interface and presses the "Send" button.

[0068] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[0069] 3. The server receives this request and passes the condition "Pokémon-style sneakers" to the generation AI.

[0070] 4. The generation AI generates an image of a sneaker featuring a Pokémon character and sends it back to the server.

[0071] 5. The server sends the generated image back to the device.

[0072] 6. The terminal displays the received image to the user, who confirms it.

[0073] This system allows users to easily obtain fashion images that suit their preferences, effectively resolving the problems that have arisen with conventional search systems.

[0074] The processing flow will be explained below.

[0075] Step 1:

[0076] The user opens the device interface and inputs the desired fashion item, such as "adult T-shirt" or "Pokémon-style sneakers," into a text field.

[0077] Step 2:

[0078] The user presses the "Send" button.

[0079] Step 3:

[0080] The terminal takes the user's input and converts it to JSON format, for example generating the following JSON data:

[0081] json

[0082] {

[0083] "query": "adult t-shirts"

[0084] }

[0085] Step 4:

[0086] The device sets this JSON data as the body of an HTTP POST request and sends it to the server.

[0087] Step 5:

[0088] The server receives an HTTP POST request from the terminal.

[0089] Step 6:

[0090] The server parses the received JSON data and extracts the condition (in this case, "adult T-shirts") from the "query" field.

[0091] Step 7:

[0092] The conditions extracted by the server are set as input data for the generation AI.

[0093] Step 8:

[0094] The server passes the conditions to the generation AI and requests it to generate a fashion image.

[0095] Step 9:

[0096] The generative AI generates fashion images based on the received conditions, where it references its internal model and past data to create the optimal image.

[0097] Step 10:

[0098] The generated AI sends the generated fashion image back to the server.

[0099] Step 11:

[0100] The server formats the received fashion images and associated metadata (e.g., color, size, and material information) into JSON format.

[0101] Step 12:

[0102] The server sends the formatted response data to the terminal as an HTTP response.

[0103] Step 13:

[0104] The terminal receives an HTTP response from the server.

[0105] Step 14:

[0106] The terminal analyzes the response data, decodes the image data, and displays it on the screen.

[0107] Step 15:

[0108] The user can view the fashion images displayed on their device, and can save or share these images.

[0109] The above is a detailed description of each step from user input to display of a fashion image.

[0110] Example 1

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

[0112] Conventional search systems have the problem that it is difficult for users to see specific visuals of the fashion items they want, and the sheer volume of search results means it takes a long time for users to find the information they are looking for. Even if users input their desired criteria, there are limited ways to obtain specific images based on those criteria. To solve these problems, a system is needed that allows users to easily obtain the fashion images they desire.

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

[0114] In this invention, the server includes means for the terminal to analyze user input data and convert it into an appropriate format, means for transmitting the formatted data to the server, means for the server to receive the formatted data, means for the server to analyze the received data and extract conditions, means for generating fashion images using a generative AI model based on the conditions, means for returning the generated fashion images to the terminal, and means for the terminal to analyze the image data received and display it to the user. This makes it possible for the user to easily and quickly obtain specific fashion images based on the conditions desired.

[0115] "User input" refers to the act of an individual using the system inputting the conditions relating to the fashion item they desire into the terminal interface.

[0116] A "terminal" is an electronic device used by a user, such as a smartphone, PC, or tablet, and is a device that receives user input and communicates with a server.

[0117] The "server" is a computer system that includes a generative AI model, receives and analyzes user input data, generates fashion images based on the conditions, and returns them to the terminal.

[0118] A "generative AI model" is an artificial intelligence algorithm that uses past data and learning models to generate fashion images that match received conditions.

[0119] A "prompt" is an instruction sentence input into a generative AI model, which includes the conditions for generating a specific fashion image.

[0120] An "HTTP POST request" is one of the communication protocols used by a terminal to send data to a server, and includes formatted input data as a request body.

[0121] "Formatting" is the process of converting the data entered by the user into a form that is easy to handle within the system (for example, JSON format).

[0122] "Data analysis" is the process of examining the data received by the server in detail, extracting conditions, and preparing it in the format required for subsequent processing.

[0123] A "user interface" is a screen or input form that allows a user to operate a system, and is used when making user input.

[0124] "Image generation" is the process by which a generative AI model creates a fashion image based on user input.

[0125] "Metadata" is additional information associated with the generated fashion image, including, for example, size, color, material, etc.

[0126] This invention relates to a system that uses a generative AI model to generate fashion images based on user-entered conditions. This system is composed of the following elements: a user, a terminal, and a server.

[0127] System configuration

[0128] The system includes the following main components:

[0129] 1. User: An individual who wants to embody the image of a fashion item.

[0130] 2. Terminal: An electronic device used by a user, such as a smartphone, PC, or tablet. It is a device that receives user input and communicates with a server.

[0131] 3. Server: A computer system that contains the generative AI model, receives user requests, and performs image generation.

[0132] Program Processing Overview

[0133] Users input the specifications for the fashion items they are looking for through their device, and this information is sent to the server. The server uses a generative AI model to generate fashion images based on the received specifications and sends the results back to the device. This allows users to obtain specific visuals of the fashion items they desire.

[0134] Hardware and software usage

[0135] In this system, devices such as smartphones, PCs, and tablets are used, and a computer system with high-performance computing capabilities is used as the server. The generative AI model uses software frameworks equipped with deep learning algorithms (e.g., TENSORFLOW (registered trademark), PyTorch, etc.). Communication between the device and the server is via the HTTP protocol, and data is sent and received in JSON format.

[0136] Specific use cases

[0137] Example 1: Generating images of adult T-shirts

[0138] 1. The user enters "adult T-shirt" into the device interface and presses the "Send" button.

[0139] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[0140] 3. The server receives this request and passes the condition "adult T-shirt" to the generative AI model.

[0141] 4. The generative AI model generates an image of a T-shirt with a simple yet sophisticated design and sends it back to the server.

[0142] 5. The server sends the generated image back to the device.

[0143] 6. The terminal displays the received image to the user, who confirms it.

[0144] Example prompt:

[0145] "Create simple yet sophisticated adult T-shirt designs."

[0146] Example 2: Image generation of Pokémon-style sneakers

[0147] 1. The user types "Pokémon-style sneakers" into the device interface and presses the "Send" button.

[0148] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[0149] 3. The server receives this request and passes the condition "Pokémon-style sneakers" to the generative AI model.

[0150] 4. The generative AI model generates images of sneakers featuring Pokémon characters and sends them back to the server.

[0151] 5. The server sends the generated image back to the device.

[0152] 6. The terminal displays the received image to the user, who confirms it.

[0153] Example prompt:

[0154] "Generate unique sneaker designs featuring Pokémon characters."

[0155] This system allows users to easily obtain fashion images that match their preferences, effectively resolving the problems that have arisen with conventional search systems. Specifically, it provides a means to resolve the problem of the large number of search results, which make it take a long time to find the desired information, and the problem of not being able to obtain a specific visual image.

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

[0157] Step 1: User input

[0158] The user uses the device interface (smartphone app or web browser) to input the desired fashion item. Specifically, the user enters a condition such as "adult T-shirt" into a text box on the screen and clicks the "Submit" button. This input data triggers the next processing step.

[0159] Input: Conditions for the desired fashion item (e.g., "Adult T-shirt")

[0160] Output: User condition input data (e.g. "Adult T-shirt")

[0161] Step 2: Convert input data format

[0162] The terminal analyzes the condition data entered by the user and converts it into a format that is easy to handle within the system. In this case, the data is converted into JSON format.

[0163] Input: User condition input data (e.g. "Adult T-shirt")

[0164] Data Calculation: Convert condition data to JSON format (e.g., {"item": "Adult T-shirt"})

[0165] Output: Formatted JSON data (e.g., {"item": "Adult T-shirt"})

[0166] Specific operation: The format conversion function on the terminal is executed.

[0167] Step 3: Sending formatted data

[0168] The terminal sends the formatted data to the server as an HTTP POST request.

[0169] Input: Formatted JSON data (e.g., {"item": "Adult T-shirt"})

[0170] Data calculation: Send data in the body of the HTTP request

[0171] Output: HTTP request sent

[0172] Specific operation: The device sends an HTTP POST request to the specified endpoint on the server.

[0173] Step 4: Receiving data on the server

[0174] The server receives the HTTP POST request sent from the terminal and extracts data from the received request body.

[0175] Input: HTTP request (including formatted JSON data)

[0176] Data operation: Extract data from the request body (e.g., {"item": "Adult T-shirt"})

[0177] Output: Extracted JSON data

[0178] Specific behavior: The receiving endpoint on the server detects the request and executes the data extraction function.

[0179] Step 5: Data analysis and condition extraction

[0180] The server analyzes the received data and extracts the conditions entered by the user. During the analysis stage, it also checks the consistency of the data.

[0181] Input: Extracted JSON data (e.g., {"item": "Adult T-shirt"})

[0182] Data calculation: Analysis and extraction of conditional data (e.g., item name "Adult T-shirt")

[0183] Output: Extracted condition data (e.g. "Adult T-shirts")

[0184] Specific operation: The server's data analysis module analyzes the data and extracts conditions.

[0185] Step 6: Image generation using generative AI

[0186] The server inputs the extracted condition data into the generative AI model and issues instructions for generating fashion images. The generative AI model uses past data and learning models to generate fashion images that match the requested conditions.

[0187] Input: Condition data (e.g. "Adult T-shirts")

[0188] Data calculation: Input as a prompt to the generative AI model (e.g., "A simple and sophisticated T-shirt for adults")

[0189] Output: Generated fashion images

[0190] Specific operation: The server passes the prompt sentence to the generative AI model, and the image generation function is executed.

[0191] Step 7: Sending the image from the server back to the device

[0192] The fashion image generated by the generative AI and its associated metadata are sent back to the device from the server as an HTTP response.

[0193] Input: Generated fashion images and metadata

[0194] Data operations: Reconstruct data into a response format (e.g., {"image": "base64-encoded-image", "size": "L", "color": "blue", "material": "cotton"})

[0195] Output: HTTP response

[0196] Specific operation: The server constructs response data and sends it to the terminal as an HTTP response.

[0197] Step 8: Displaying the image to the user

[0198] The device receives the HTTP response from the server, analyzes the image data, and displays it to the user, who can then check the final image of the fashion item.

[0199] Input: HTTP response (including image data and metadata)

[0200] Data calculation: Analysis of response data

[0201] Output: The image displayed in the user interface

[0202] Specific operation: The device analyzes the response and displays the image data on the screen.

[0203] (Application example 1)

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

[0205] To provide a system for generating fashion images based on conditions input by a user, with a means for enabling a user to try on and check the generated fashion images, thereby enabling the user to easily obtain specific visual feedback that cannot be obtained by a normal search system.

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

[0207] In this invention, the server includes means for generating individual fashion images based on conditions input by the user and means for allowing the user to virtually try on the generated fashion images, thereby enabling the user to apply the fashion images generated based on the conditions input to their own photos or avatars and check specific styling.

[0208] A "user" is an individual who wants to embody the image of a fashion item.

[0209] A "terminal" is an electronic device used by a user, such as a smartphone, PC, or tablet.

[0210] A "server" is a computer system that includes a generation AI and receives user requests and generates images.

[0211] "Generative AI" is an artificial intelligence model that generates fashion images based on conditions entered by the user.

[0212] "Conditions" refer to detailed information and desired characteristics about a fashion item that a user inputs into a terminal.

[0213] "Fashion images" are visual representations of fashion items created by generative AI.

[0214] "Virtual try-on" refers to a user applying a generated fashion image to their own photo or avatar, allowing them to check the look as if they were trying it on.

[0215] The system for implementing this invention is composed of a user, a terminal, and a server. Specifically, the user inputs fashion parameters using a terminal such as a smartphone, and a generation AI generates fashion images based on the parameters. Finally, the system provides a means for the user to virtually try on the images.

[0216] System Program Overview

[0217] First, the user uses the device to input fashion criteria based on their preferences. For example, a condition could be "casual autumn outfit coordination." This input data is converted into an appropriate format (e.g., JSON format) by the device and sent to the server as an HTTP request.

[0218] The server receives requests using a web framework called Flask. The received data is analyzed and condition data is extracted. This condition data is passed to an AI model library (tentative name: some_ai_module). This AI model uses past data and learning models to generate fashion images based on the user's requests.

[0219] The generated fashion image is sent back from the server to the device. The device displays the received fashion image to the user. At this time, the user can virtually try on the generated fashion image. Virtual try-on refers to overlaying the fashion image on the user's photo or avatar, allowing the user to check how the item will look when actually worn.

[0220] Hardware and software used

[0221] Hardware: General cloud servers, smartphones, tablets, etc.

[0222] Software: Flask (web framework), some_ai_module (AI model library)

[0223] Specific examples

[0224] As a specific example, if a user wants to coordinate casual autumn clothing, the user can follow the following steps.

[0225] 1. The user opens the smartphone application interface and enters "Casual Fall Outfit Coordination."

[0226] 2. By pressing the "Send" button, the device converts the input data into JSON format and sends an HTTP POST request to the server.

[0227] 3. The server receives the request and parses and extracts the condition data.

[0228] 4. Use some_ai_module to generate fashion images based on conditions.

[0229] 5. The generated image is sent back from the server to the device.

[0230] 6. The user checks the generated image on the device and tries on the clothes virtually.

[0231] Prompt Sentence Examples

[0232] The user inputs "Casual autumn outfit coordination" as a prompt sentence. Then, the user presses the send button to send the data to the server.

[0233] This allows users to easily create their desired fashion image and check the visual feedback through virtual try-on, making it easier for users to select and purchase more specific fashion items.

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

[0235] Step 1:

[0236] The user inputs fashion criteria using the terminal. For example, the user inputs a criteria such as "casual autumn outfit coordination" into a text field.

[0237] Step 2:

[0238] The user presses the "Submit" button to send the input data from the device to the server, which then converts the input data into an appropriate format (e.g., JSON) and sends it to the server as an HTTP POST request.

[0239] Step 3:

[0240] The server uses Flask to receive HTTP requests from users, which are then parsed in JSON format to extract conditional data.

[0241] Step 4:

[0242] The server prepares the analyzed condition data to be passed to the generation AI. Specifically, it converts the data into the required format so that it can be input to the generation AI.

[0243] Step 5:

[0244] The server inputs condition data into the generation AI (some_ai_module) and generates fashion images. The generation AI uses past data and learning models to generate the optimal fashion images that match the conditions.

[0245] Step 6:

[0246] After the generation AI generates the fashion image, the server receives the generated image data and prepares to send it back to the device in JSON format.

[0247] Step 7:

[0248] The server returns the generated fashion image data to the terminal as an HTTP response.

[0249] Step 8:

[0250] The device analyzes the received fashion image data and displays it to the user, who can then check the displayed image and save or share it as needed.

[0251] Step 9:

[0252] Users can virtually try on the generated fashion images. Specifically, the fashion images are superimposed on the user's photo or avatar, allowing them to see how they will look when actually worn.

[0253] In this way, the user can specifically check and try on the fashion image generated based on the conditions input by the user.

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

[0255] The present invention relates to a system that generates individual fashion images based on user-entered conditions, recognizes the user's emotions, and provides optimal fashion images based on those emotions. This system is composed of components: a user, a terminal, a server, and an emotion engine. The details are described below.

[0256] System configuration

[0257] The system includes the following major components:

[0258] 1. User: An individual who wants to embody the image of a fashion item.

[0259] 2. Device: Electronic devices used by users, such as smartphones, computers, and tablets.

[0260] 3. Server: A computer system that includes a generation AI and receives user requests and performs image generation.

[0261] 4. Emotion engine: Recognizes the user's emotions along with the user's input conditions and performs analysis based on those emotions.

[0262] Program Processing Overview

[0263] The user inputs the specifications for the fashion items through the device, and this information, along with the user's emotional state, is sent to the server. The server uses a generative AI and emotion engine to generate fashion images based on the received specifications and emotional state, and sends the results back to the device. This allows the user to receive specific visuals of the fashion items they desire and suggestions that fit their emotions.

[0264] Program Processing Details

[0265] User Input

[0266] The user opens the device's interface and inputs the desired fashion item, such as an "adult T-shirt" or "Pokémon-style sneakers." As the user inputs the information, the device's camera, microphone, and other sensors capture the user's emotional state (e.g., smile, surprise, sadness, etc.). The user's emotional state and the conditions are then recorded together.

[0267] Input data formatting and transmission

[0268] The device analyzes the user's input data and emotional state, converts it into an appropriate format (e.g., JSON), and sends it to the server as an HTTP POST request.

[0269] Data reception and analysis on the server

[0270] The server receives requests sent from the device and analyzes the input data and emotional state. Conditions and emotional states are extracted from the analyzed data and prepared for passing to the generative AI and emotion engine.

[0271] Image generation with generative AI and emotion engine

[0272] The server passes the conditions to the generation AI and the emotional state to the emotion engine. The emotion engine adjusts the output of the generation AI based on the emotional state. The generation AI generates fashion images that match the conditions and adjusts the optimal design, color, and style based on the emotion.

[0273] Returning images

[0274] The generated fashion image and associated metadata (e.g., size, color, and material information) are sent back from the server to the device as an HTTP response.

[0275] Displaying an image to the user

[0276] The device analyzes the image data received from the server and displays it to the user, who can then view the image and save or share it as needed.

[0277] Specific use cases

[0278] Example 1: Generating images of adult T-shirts

[0279] 1. The user types "adult T-shirt" into the device interface, and the camera simultaneously captures the user's smile.

[0280] 2. The device converts the input data and emotional state ("smile") into JSON format and sends an HTTP request to the server.

[0281] 3. The server receives this request and passes the condition "adult T-shirt" and the emotional state "smiling" to the generation AI and emotion engine.

[0282] 4. Generative AI generates images of T-shirts with simple and sophisticated designs, while the emotion engine suggests brighter colors and more cheerful designs.

[0283] 5. The server sends the adjusted image back to the device.

[0284] 6. The terminal displays the received image to the user, who confirms it.

[0285] Example 2: Image generation of Pokémon-style sneakers

[0286] 1. The user types "Pokémon-style sneakers" into the device interface, and the microphone simultaneously captures the user's excited voice.

[0287] 2. The device converts the input data and emotional state ("excitement") into JSON format and sends an HTTP request to the server.

[0288] 3. The server receives this request and passes the condition "Pokémon-style sneakers" and the emotional state "excited" to the generation AI and emotion engine.

[0289] 4. The generative AI generates images of sneakers based on Pokémon characters, and the emotion engine adjusts the designs to be more eye-catching and vibrant in color.

[0290] 5. The server sends the adjusted image back to the device.

[0291] 6. The terminal displays the received image to the user, who confirms it.

[0292] This system allows users to easily obtain fashion images that match their preferences, and also allows them to receive suggestions that suit their emotions at the time. The use of an emotion engine effectively solves the problems that arise in conventional search systems, improving the user experience.

[0293] The processing flow will be explained below.

[0294] Step 1:

[0295] The user opens the device's interface and inputs the desired fashion item, such as "adult T-shirt" or "Pokémon-style sneakers," into a text field. The device's camera and microphone also collect emotional data, such as the user's facial expressions and voice.

[0296] Step 2:

[0297] The user presses the "Send" button.

[0298] Step 3:

[0299] The device receives the user's input and emotion data and converts it into JSON format. For example, it generates the following JSON data:

[0300] json

[0301] {

[0302] "query": "adult t-shirt",

[0303] "emotion": "smile"

[0304] }

[0305] Step 4:

[0306] The device sets this JSON data as the body of an HTTP POST request and sends it to the server.

[0307] Step 5:

[0308] The server receives an HTTP POST request from the terminal.

[0309] Step 6:

[0310] The server parses the received JSON data and extracts the condition (in this case, "adult T-shirt") from the "query" field and the emotional state (in this case, "smiling") from the "emotion" field.

[0311] Step 7:

[0312] The conditions extracted by the server are input into the generation AI, and the emotional state is input into the emotion engine.

[0313] Step 8:

[0314] The server passes the conditions to the generation AI and requests it to generate a fashion image. At the same time, it passes the emotional state to the emotion engine and requests it to perform emotion-based analysis.

[0315] Step 9:

[0316] The generative AI generates fashion images based on the received conditions, and then references past data and learning models to create the optimal image.

[0317] Step 10:

[0318] The emotion engine adjusts the generated fashion image based on the user's emotional state, for example, adjusting the design to favor bright colors and a lively style if the emotional state is "smiling."

[0319] Step 11:

[0320] The server formats the generated fashion images and associated metadata (e.g., color, size, and material information) into JSON format.

[0321] Step 12:

[0322] The server sends the formatted response data to the terminal as an HTTP response.

[0323] Step 13:

[0324] The terminal receives an HTTP response from the server.

[0325] Step 14:

[0326] The terminal analyzes the response data, decodes the image data, and displays it on the screen.

[0327] Step 15:

[0328] The user can view the fashion images displayed on their device, and can save or share these images.

[0329] The above is a detailed description of each step from processing user input and emotion data to displaying fashion images.

[0330] Example 2

[0331] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0332] Conventional fashion image generation systems generate images based only on the user's desired conditions, and therefore do not provide suggestions that reflect the emotional state of each individual user. This makes it difficult to increase user satisfaction. Furthermore, the process of formatting the user's input data, sending it to the server, and analyzing it is inefficient, making it difficult to respond in real time. There is a need for a system that can propose appropriate fashion images based on the user's individual emotional state.

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

[0334] In this invention, the server includes means for generating individual fashion images based on conditions and emotional state input by a user and providing the generated images to the user, means for receiving the conditions and emotional state input by the user to a terminal, means for the terminal to format the conditions and emotional state into an appropriate data format and transmit the data to the server, means for the server to analyze the received data and extract the conditions and emotional state, means for generating fashion images using a generative AI model based on the conditions and adjusting the fashion images generated by an emotion engine based on the emotional state, means for returning the generated and adjusted fashion images to the terminal, and means for the terminal to display the generated and adjusted fashion images to the user. This enables more personalized fashion images to be proposed according to the user's emotional state, thereby increasing user satisfaction.

[0335] A "user" is an individual who wants to embody the image of a fashion item.

[0336] A "terminal" is an electronic device used by a user, such as a smartphone, PC, or tablet.

[0337] "Conditions" are information that indicates specific requirements or features of the fashion item desired by the user.

[0338] "Emotional state" is information that indicates the user's psychological and emotional state at any given time.

[0339] The "receiving means" includes mechanisms and functions for acquiring the conditions and emotional states input by the user to the terminal.

[0340] The "formatting means" has the function of converting the conditions and emotional state input by the user into an appropriate data format.

[0341] The "transmission means" includes a mechanism and a protocol for transmitting the data converted by the formatting means to the server.

[0342] The "analysis means" has the function of analyzing the data received by the server and extracting the condition and emotional state.

[0343] A "generative AI model" is an artificial intelligence model used to generate fashion images based on input conditions.

[0344] An "emotional engine" includes mechanisms and algorithms for adjusting the generated fashion image based on the user's emotional state.

[0345] The "returning means" includes mechanisms and protocols for returning the generated and adjusted fashion images to the terminal.

[0346] The "display means" has a mechanism and function for visually presenting the received fashion image to the user.

[0347] The present invention relates to a system that generates and provides individual fashion images to users based on conditions and emotional states input by the user. The system is composed of components including a user, a terminal, a server, and an emotion engine.

[0348] System Configuration

[0349] User

[0350] A user is an individual who wants to embody the image of a fashion item, and is a user of the system.

[0351] Terminal

[0352] The device is an electronic device used by the user, such as a smartphone, PC, tablet, etc. The user inputs conditions through the device, and the emotional state is acquired using sensors such as a camera and microphone.

[0353] server

[0354] The server is a computer system that contains the generative AI model and emotion engine and processes user requests. The server receives user input data, analyzes it, and performs the necessary processing.

[0355] Emotion Engine

[0356] The emotion engine is a software component for analyzing the user's emotional state and adjusting the generated fashion image based on that information.

[0357] Program Processing Details

[0358] User Input

[0359] The user opens the device's interface and inputs the desired fashion item, such as an "adult T-shirt" or "Pokémon-style sneakers." As the user inputs the information, the device's camera, microphone, and other sensors capture the user's emotional state (e.g., smile, surprise, sadness, etc.). These conditions and the emotional state are then recorded.

[0360] Input data formatting and transmission

[0361] The device analyzes the user's input data and emotional state, converts it into an appropriate data format (e.g., JSON), and then sends this data to the server as an HTTP POST request.

[0362] Data reception and analysis on the server

[0363] The server receives the HTTP POST request sent from the device and analyzes the input data and emotional state. The analyzed data is separated into conditions and emotional states, and is ready to be passed to the generative AI and emotion engine.

[0364] Image generation with generative AI and emotion engine

[0365] The server sends the user's input conditions (such as "adult T-shirt" or "Pokémon-style sneakers") to the generative AI model, and sends the user's emotional data (such as "smile" or "excitement") to the emotion engine. The generative AI generates fashion images that match the conditions, and the emotion engine adjusts the generated images appropriately based on the user's emotional state.

[0366] Returning and viewing images

[0367] The generated fashion image and related metadata (size, color, material information, etc.) are sent back from the server to the device as an HTTP response. The device analyzes the received image data and displays it in the user's interface. The user can then view the displayed image and save or share it as desired.

[0368] Specific use cases

[0369] Example 1: Generating images of adult T-shirts

[0370] 1. The user types "adult T-shirt" into the device interface, and the camera simultaneously captures the user's smile.

[0371] 2. The device converts the input data and emotional state ("smile") into JSON format and sends an HTTP request to the server.

[0372] 3. The server receives this request and passes the condition "adult T-shirt" and the emotional state "smiling" to the generative AI model and emotion engine.

[0373] 4. The generative AI model generates images of T-shirts with simple and sophisticated designs, while the emotion engine suggests brighter colors and more cheerful designs.

[0374] 5. The server sends the adjusted image back to the device.

[0375] 6. The terminal displays the received image to the user, who confirms it.

[0376] Example 2: Image generation of Pokémon-style sneakers

[0377] 1. The user types "Pokémon-style sneakers" into the device interface, and the microphone simultaneously captures the user's excited voice.

[0378] 2. The device converts the input data and emotional state ("excitement") into JSON format and sends an HTTP request to the server.

[0379] 3. The server receives this request and passes the condition "Pokémon-style sneakers" and the emotional state "excited" to the generative AI model and emotion engine.

[0380] 4. The generative AI model generates images of sneakers featuring Pokémon characters, and the emotion engine adjusts for more eye-catching designs and vibrant colors.

[0381] 5. The server sends the adjusted image back to the device.

[0382] 6. The terminal displays the received image to the user, who confirms it.

[0383] Prompt Sentence Examples

[0384] For adult t-shirt production:

[0385] "Generate simple yet sophisticated t-shirt designs for adults. Users smile."

[0386] To create Pokémon-style sneakers:

[0387] "Generate sneakers with eye-catching designs and vibrant colors featuring Pokémon characters. Users are super excited."

[0388] This system allows users to easily obtain fashion images that match their preferences and emotions, and enjoy a more personalized experience. The use of an emotion engine solves the issues that existed in conventional search systems, dramatically improving the user experience.

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

[0390] Step 1:

[0391] The user opens the interface using a device and inputs the conditions for the desired fashion item. Specifically, they enter "adult T-shirt" or "Pokémon-style sneakers" into the device's input field. At the same time, the device's camera and microphone are used to detect the user's emotional state (e.g., smiling, excited). The conditions and emotional state are obtained as input data.

[0392] Step 2:

[0393] The device receives and analyzes the user's input data (conditions and emotional state). Specifically, it analyzes sensor data from the camera and microphone to obtain emotional states such as smiles and excitement. It then converts this data into JSON format. The input is the user's condition and emotional state data, and the output is the data converted into JSON format.

[0394] Step 3:

[0395] The terminal sends the converted data to the server as an HTTP POST request. At this time, the endpoint URL of the server to which the data is to be sent is used. The input is the data converted to JSON format, and the output is the HTTP request sent to the server.

[0396] Step 4:

[0397] The server receives an HTTP POST request sent from the device. The received data is analyzed to separate the conditions and emotional state entered by the user. The input is the HTTP request data, and the output is the analyzed conditions and emotional state.

[0398] Step 5:

[0399] Based on the analyzed data, the server sends conditions to the generative AI model and emotional states to the emotion engine. The generative AI model generates an initial fashion image based on the conditions, and the emotion engine adjusts this image based on the emotional state. The input is the conditions and emotional state, and the output is the generated and adjusted fashion image.

[0400] Step 6:

[0401] The server returns the generated and adjusted fashion images and related metadata (size, color, material information, etc.) to the device as an HTTP response. The input is the generated and adjusted image data, and the output is the HTTP response to the device.

[0402] Step 7:

[0403] The device analyzes the fashion image data received from the server and displays it on the user's interface, allowing the user to check the generated image and save or share it. The input is the image data received as an HTTP response, and the output is the display to the user.

[0404] (Application example 2)

[0405] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0406] In the modern fashion industry, users have to make a lot of effort to narrow down their choices from a wide variety of items. Furthermore, conventional fashion image generation systems lack personalized suggestions based on the user's emotions, making it difficult to find outfits that fit the user's actual needs and mood. In particular, in virtual stores, it is necessary to provide more appropriate fashion suggestions based on emotions when users virtually try on clothes.

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

[0408] In this invention, the server includes means for receiving conditions input to the terminal by the user, means for generating fashion images using a generation AI based on the conditions, means for returning the generated fashion images to the terminal, means for detecting the user's emotions using an emotion recognition engine, means for adjusting the output of the generation AI based on the detected emotions, and means for displaying the adjusted fashion images on the terminal. This allows users to easily obtain fashion images that suit their emotions and moods, and to find the optimal coordination that fits their emotions in a virtual store.

[0409] A "user" refers to an individual who wishes to embody a fashion image.

[0410] "Terminal" refers to electronic devices used by users, such as smartphones, personal computers, and tablets.

[0411] "Conditions" refer to the desires and requests regarding fashion items that a user inputs into the terminal.

[0412] "Generative AI" refers to artificial intelligence that generates new fashion images based on conditions entered by the user.

[0413] "Fashion image" refers to the visual of a specific fashion item generated by generative AI.

[0414] An "emotion recognition engine" is an engine that detects and analyzes user emotions and provides data to adjust the output of generative AI.

[0415] "Server" refers to the central computer system that receives and processes user input data and emotion data.

[0416] "Means for receiving" refers to the function by which the server receives the conditions and emotion data sent from the terminal.

[0417] "Means for generation" refers to the function by which the generative AI creates fashion images based on the received conditions.

[0418] "Means for sending back" refers to the function of sending back the generated fashion image from the server to the terminal.

[0419] "Means for detecting" refers to a function for recognizing a user's emotions and analyzing their emotional state.

[0420] "Adjustment means" refers to a function for optimizing the output of the generative AI based on the emotions detected by the emotion recognition engine.

[0421] "Display means" refers to a function that visually presents the fashion images received by the terminal from the server to the user.

[0422] This invention is a system that generates individual fashion images based on user-entered conditions, recognizes the user's emotions, and provides optimal fashion images based on those emotions. This system consists of a user, a terminal, a server, an emotion recognition engine, and a generation AI model.

[0423] System configuration

[0424] The system includes the following major components:

[0425] 1. User: An individual who wants to embody the image of a fashion item.

[0426] 2. Device: Electronic devices used by users, such as smartphones, computers, and tablets.

[0427] 3. Server: A computer system that includes a generation AI and receives user requests and performs image generation.

[0428] 4. Emotion recognition engine: Recognizes the user's emotions along with the user's input conditions and performs analysis based on those emotions.

[0429] System Operation Overview

[0430] Users input their desired fashion item preferences through their device, and this information, along with the user's emotional state, is sent to the server. The server then uses a generative AI and emotion recognition engine to generate fashion images based on the received preferences and emotional state, and sends the results back to the device. This allows users to receive specific visuals of their desired fashion items and suggestions that fit their emotions.

[0431] Detailed explanation of program processing

[0432] First, the user inputs the desired fashion items into the device interface. At the same time, the user's emotional state is also captured through sensors such as the device's camera and microphone. This information is converted into an appropriate format and sent to the server as an HTTP request.

[0433] The server receives this request and analyzes the input data and emotional data. Conditions and emotional states are extracted from the analyzed data and passed to the generation AI and emotion recognition engine. The generation AI generates fashion images that fit the conditions, and the emotion recognition engine adjusts them based on the emotional state. The generated fashion images are then sent back to the device from the server along with related metadata.

[0434] Hardware and software used

[0435] The system uses the following hardware and software:

[0436] Smartphones, computers, tablets, etc.: the devices through which users interact with the interface.

[0437] Emotion recognition engine: An engine for analyzing user emotions.

[0438] Generative AI model: An artificial intelligence model for generating fashion images.

[0439] HTTP request processing library: A software tool for sending and receiving data.

[0440] Specific examples

[0441] For example, if a user inputs "rock-style jacket" into the device interface and the camera captures an excited expression, the server receives the criteria "rock-style jacket" and the emotional state of "excited." The generative AI generates a rock-style jacket, and the emotion recognition engine suggests more flashy designs and dynamic colors. The final image is sent back to the user for review.

[0442] Example prompt sentence:

[0443] "Fashion item: Rock style jacket, Emotion: Excitement"

[0444] This allows users to receive personalized fashion suggestions based on their emotions.

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

[0446] Step 1:

[0447] The user opens the device interface and inputs the desired fashion item. For example, they might type "rock style jacket" into a text box. The device's camera and microphone also capture the user's emotional state (e.g., smile, surprise, excitement). The input data and emotional data are collected and stored on the device.

[0448] Input: A condition about a fashion item ("rock-style jacket") and the user's emotional state ("excitement")

[0449] Output: Input data and emotion data collected and saved on the device

[0450] Step 2:

[0451] The device converts the collected user input data and emotion data into an appropriate format (e.g., JSON format) and sends it to the server as an HTTP POST request. This data includes the user's desired fashion item conditions and emotional state.

[0452] Input: Input data and emotion data stored on the device

[0453] Output: HTTP POST request sent to the server

[0454] Step 3:

[0455] The server receives the HTTP POST request sent from the device, analyzes the data, extracts conditions and emotional states from the received data, and prepares the data for passing to the generative AI model and emotion recognition engine.

[0456] Input: HTTP POST request sent from the terminal

[0457] Output: Input data to the generative AI model and emotion recognition engine

[0458] Step 4:

[0459] The generative AI model generates fashion images based on the condition data it receives. Furthermore, the emotion recognition engine adjusts the output of the generative AI model based on the emotional state data it receives. For example, if the emotion is "excited," it adjusts the design and color to be more flashy and dynamic.

[0460] Input: Condition data for generative AI models, and emotional state data for emotion recognition engines

[0461] Output: Adjusted fashion image

[0462] Step 5:

[0463] The server returns the adjusted fashion image obtained from the generative AI model and emotion recognition engine, along with related metadata (e.g., size, color, and material information), to the device as an HTTP response.

[0464] Input: Adjusted fashion images and associated metadata

[0465] Output: HTTP response to the device

[0466] Step 6:

[0467] The device analyzes the HTTP response received from the server and displays the fashion image to the user, who can then check the displayed image and save or share it as needed.

[0468] Input: HTTP response received from the server

[0469] Output: Fashion images displayed to the user

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

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

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

[0473] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0486] This invention relates to a system that uses generative AI to generate fashion images based on conditions entered by a user. This system is composed of elements including a user, a terminal, and a server, and is described in detail below.

[0487] System configuration

[0488] The system includes the following major components:

[0489] 1. User: An individual who wants to embody the image of a fashion item.

[0490] 2. Device: Electronic devices used by users, such as smartphones, computers, and tablets.

[0491] 3. Server: A computer system that includes a generation AI and receives user requests and performs image generation.

[0492] Program Processing Overview

[0493] Users input the specifications for the fashion items they are looking for through their device, and this information is sent to the server. The server uses generative AI to generate fashion images based on the received specifications and sends the results back to the device. This allows users to obtain specific visuals of the fashion items they desire.

[0494] Program Processing Details

[0495] User Input

[0496] Users open a dedicated interface on their device and enter the desired fashion items, such as "adult T-shirts" or "Pokémon-style sneakers." Once the input is complete, the data is sent by clicking the "Send" button.

[0497] Input data formatting and transmission

[0498] The device parses the user's input data, converts it into an appropriate format (e.g., JSON), and sends it to the server as an HTTP POST request.

[0499] Data reception and analysis on the server

[0500] The server receives the request sent from the device and analyzes the input data. Conditions are extracted from the analyzed data and prepared for passing to the generation AI.

[0501] Image generation by generative AI

[0502] The server passes the analysis results to the generation AI as input data. Based on this, the generation AI generates fashion images that match the conditions. The generation AI uses past data and learning models to create the optimal image.

[0503] Returning images

[0504] The generated fashion image and associated metadata (e.g., size, color, and material information) are sent back to the terminal as an HTTP response from the server.

[0505] Displaying an image to the user

[0506] The device analyzes the image data received from the server and displays it to the user, who can then view the image and save or share it as needed.

[0507] Specific use cases

[0508] Example 1: Generating images of adult T-shirts

[0509] 1. The user enters "adult T-shirt" into the device interface and presses the "Send" button.

[0510] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[0511] 3. The server receives this request and passes the condition "adult T-shirt" to the generation AI.

[0512] 4. The generative AI generates an image of a T-shirt with a simple yet sophisticated design and sends it back to the server.

[0513] 5. The server sends the generated image back to the device.

[0514] 6. The terminal displays the received image to the user, who confirms it.

[0515] Example 2: Image generation of Pokémon-style sneakers

[0516] 1. The user types "Pokémon-style sneakers" into the device interface and presses the "Send" button.

[0517] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[0518] 3. The server receives this request and passes the condition "Pokémon-style sneakers" to the generation AI.

[0519] 4. The generation AI generates an image of a sneaker featuring a Pokémon character and sends it back to the server.

[0520] 5. The server sends the generated image back to the device.

[0521] 6. The terminal displays the received image to the user, who confirms it.

[0522] This system allows users to easily obtain fashion images that suit their preferences, effectively resolving the problems that have arisen with conventional search systems.

[0523] The processing flow will be explained below.

[0524] Step 1:

[0525] The user opens the device interface and inputs the desired fashion item, such as "adult T-shirt" or "Pokémon-style sneakers," into a text field.

[0526] Step 2:

[0527] The user presses the "Send" button.

[0528] Step 3:

[0529] The terminal takes the user's input and converts it to JSON format, for example generating the following JSON data:

[0530] json

[0531] {

[0532] "query": "adult t-shirts"

[0533] }

[0534] Step 4:

[0535] The device sets this JSON data as the body of an HTTP POST request and sends it to the server.

[0536] Step 5:

[0537] The server receives an HTTP POST request from the terminal.

[0538] Step 6:

[0539] The server parses the received JSON data and extracts the condition (in this case, "adult T-shirts") from the "query" field.

[0540] Step 7:

[0541] The conditions extracted by the server are set as input data for the generation AI.

[0542] Step 8:

[0543] The server passes the conditions to the generation AI and requests it to generate a fashion image.

[0544] Step 9:

[0545] The generative AI generates fashion images based on the received conditions, where it references its internal model and past data to create the optimal image.

[0546] Step 10:

[0547] The generated AI sends the generated fashion image back to the server.

[0548] Step 11:

[0549] The server formats the received fashion images and associated metadata (e.g., color, size, and material information) into JSON format.

[0550] Step 12:

[0551] The server sends the formatted response data to the terminal as an HTTP response.

[0552] Step 13:

[0553] The terminal receives an HTTP response from the server.

[0554] Step 14:

[0555] The terminal analyzes the response data, decodes the image data, and displays it on the screen.

[0556] Step 15:

[0557] The user can view the fashion images displayed on their device, and can save or share these images.

[0558] The above is a detailed description of each step from user input to display of a fashion image.

[0559] Example 1

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

[0561] Conventional search systems have the problem that it is difficult for users to see specific visuals of the fashion items they want, and the sheer volume of search results means it takes a long time for users to find the information they are looking for. Even if users input their desired criteria, there are limited ways to obtain specific images based on those criteria. To solve these problems, a system is needed that allows users to easily obtain the fashion images they desire.

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

[0563] In this invention, the server includes means for the terminal to analyze user input data and convert it into an appropriate format, means for transmitting the formatted data to the server, means for the server to receive the formatted data, means for the server to analyze the received data and extract conditions, means for generating fashion images using a generative AI model based on the conditions, means for returning the generated fashion images to the terminal, and means for the terminal to analyze the image data received and display it to the user. This makes it possible for the user to easily and quickly obtain specific fashion images based on the conditions desired.

[0564] "User input" refers to the act of an individual using the system inputting the conditions relating to the fashion item they desire into the terminal interface.

[0565] A "terminal" is an electronic device used by a user, such as a smartphone, PC, or tablet, and is a device that receives user input and communicates with a server.

[0566] The "server" is a computer system that includes a generative AI model, receives and analyzes user input data, generates fashion images based on the conditions, and returns them to the terminal.

[0567] A "generative AI model" is an artificial intelligence algorithm that uses past data and learning models to generate fashion images that match received conditions.

[0568] A "prompt" is an instruction sentence input into a generative AI model, which includes the conditions for generating a specific fashion image.

[0569] An "HTTP POST request" is one of the communication protocols used by a terminal to send data to a server, and includes formatted input data as a request body.

[0570] "Formatting" is the process of converting the data entered by the user into a form that is easy to handle within the system (for example, JSON format).

[0571] "Data analysis" is the process of examining the data received by the server in detail, extracting conditions, and preparing it in the format required for subsequent processing.

[0572] A "user interface" is a screen or input form that allows a user to operate a system, and is used when making user input.

[0573] "Image generation" is the process by which a generative AI model creates a fashion image based on user input.

[0574] "Metadata" is additional information associated with the generated fashion image, including, for example, size, color, material, etc.

[0575] This invention relates to a system that uses a generative AI model to generate fashion images based on user-entered conditions. This system is composed of the following elements: a user, a terminal, and a server.

[0576] System configuration

[0577] The system includes the following main components:

[0578] 1. User: An individual who wants to embody the image of a fashion item.

[0579] 2. Terminal: An electronic device used by a user, such as a smartphone, PC, or tablet. It is a device that receives user input and communicates with a server.

[0580] 3. Server: A computer system that contains the generative AI model, receives user requests, and performs image generation.

[0581] Program Processing Overview

[0582] Users input the specifications for the fashion items they are looking for through their device, and this information is sent to the server. The server uses a generative AI model to generate fashion images based on the received specifications and sends the results back to the device. This allows users to obtain specific visuals of the fashion items they desire.

[0583] Hardware and software usage

[0584] In this system, devices such as smartphones, PCs, and tablets are used, and the server is a computer system with high-performance computing capabilities. The generative AI model uses software frameworks with deep learning algorithms (e.g., TensorFlow, PyTorch, etc.). Communication between the device and server is via the HTTP protocol, with data being sent and received in JSON format.

[0585] Specific use cases

[0586] Example 1: Generating images of adult T-shirts

[0587] 1. The user enters "adult T-shirt" into the device interface and presses the "Send" button.

[0588] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[0589] 3. The server receives this request and passes the condition "adult T-shirt" to the generative AI model.

[0590] 4. The generative AI model generates an image of a T-shirt with a simple yet sophisticated design and sends it back to the server.

[0591] 5. The server sends the generated image back to the device.

[0592] 6. The terminal displays the received image to the user, who confirms it.

[0593] Example prompt:

[0594] "Create simple yet sophisticated adult T-shirt designs."

[0595] Example 2: Image generation of Pokémon-style sneakers

[0596] 1. The user types "Pokémon-style sneakers" into the device interface and presses the "Send" button.

[0597] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[0598] 3. The server receives this request and passes the condition "Pokémon-style sneakers" to the generative AI model.

[0599] 4. The generative AI model generates images of sneakers featuring Pokémon characters and sends them back to the server.

[0600] 5. The server sends the generated image back to the device.

[0601] 6. The terminal displays the received image to the user, who confirms it.

[0602] Example prompt:

[0603] "Generate unique sneaker designs featuring Pokémon characters."

[0604] This system allows users to easily obtain fashion images that match their preferences, effectively resolving the problems that have arisen with conventional search systems. Specifically, it provides a means to resolve the problem of the large number of search results, which make it take a long time to find the desired information, and the problem of not being able to obtain a specific visual image.

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

[0606] Step 1: User input

[0607] The user uses the device interface (smartphone app or web browser) to input the desired fashion item. Specifically, the user enters a condition such as "adult T-shirt" into a text box on the screen and clicks the "Submit" button. This input data triggers the next processing step.

[0608] Input: Conditions for the desired fashion item (e.g., "Adult T-shirt")

[0609] Output: User condition input data (e.g. "Adult T-shirt")

[0610] Step 2: Convert input data format

[0611] The terminal analyzes the condition data entered by the user and converts it into a format that is easy to handle within the system. In this case, the data is converted into JSON format.

[0612] Input: User condition input data (e.g. "Adult T-shirt")

[0613] Data Calculation: Convert condition data to JSON format (e.g., {"item": "Adult T-shirt"})

[0614] Output: Formatted JSON data (e.g., {"item": "Adult T-shirt"})

[0615] Specific operation: The format conversion function on the terminal is executed.

[0616] Step 3: Sending formatted data

[0617] The terminal sends the formatted data to the server as an HTTP POST request.

[0618] Input: Formatted JSON data (e.g., {"item": "Adult T-shirt"})

[0619] Data calculation: Send data in the body of the HTTP request

[0620] Output: HTTP request sent

[0621] Specific operation: The device sends an HTTP POST request to the specified endpoint on the server.

[0622] Step 4: Receiving data on the server

[0623] The server receives the HTTP POST request sent from the terminal and extracts data from the received request body.

[0624] Input: HTTP request (including formatted JSON data)

[0625] Data operation: Extract data from the request body (e.g., {"item": "Adult T-shirt"})

[0626] Output: Extracted JSON data

[0627] Specific behavior: The receiving endpoint on the server detects the request and executes the data extraction function.

[0628] Step 5: Data analysis and condition extraction

[0629] The server analyzes the received data and extracts the conditions entered by the user. During the analysis stage, it also checks the consistency of the data.

[0630] Input: Extracted JSON data (e.g., {"item": "Adult T-shirt"})

[0631] Data calculation: Analysis and extraction of conditional data (e.g., item name "Adult T-shirt")

[0632] Output: Extracted condition data (e.g. "Adult T-shirts")

[0633] Specific operation: The server's data analysis module analyzes the data and extracts conditions.

[0634] Step 6: Image generation using generative AI

[0635] The server inputs the extracted condition data into the generative AI model and issues instructions for generating fashion images. The generative AI model uses past data and learning models to generate fashion images that match the requested conditions.

[0636] Input: Condition data (e.g. "Adult T-shirts")

[0637] Data calculation: Input as a prompt to the generative AI model (e.g., "A simple and sophisticated T-shirt for adults")

[0638] Output: Generated fashion images

[0639] Specific operation: The server passes the prompt sentence to the generative AI model, and the image generation function is executed.

[0640] Step 7: Sending the image from the server back to the device

[0641] The fashion image generated by the generative AI and its associated metadata are sent back to the device from the server as an HTTP response.

[0642] Input: Generated fashion images and metadata

[0643] Data operations: Reconstruct data into a response format (e.g., {"image": "base64-encoded-image", "size": "L", "color": "blue", "material": "cotton"})

[0644] Output: HTTP response

[0645] Specific operation: The server constructs response data and sends it to the terminal as an HTTP response.

[0646] Step 8: Displaying the image to the user

[0647] The device receives the HTTP response from the server, analyzes the image data, and displays it to the user, who can then check the final image of the fashion item.

[0648] Input: HTTP response (including image data and metadata)

[0649] Data calculation: Analysis of response data

[0650] Output: The image displayed in the user interface

[0651] Specific operation: The device analyzes the response and displays the image data on the screen.

[0652] (Application example 1)

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

[0654] To provide a system for generating fashion images based on conditions input by a user, with a means for enabling a user to try on and check the generated fashion images, thereby enabling the user to easily obtain specific visual feedback that cannot be obtained by a normal search system.

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

[0656] In this invention, the server includes means for generating individual fashion images based on conditions input by the user and means for allowing the user to virtually try on the generated fashion images, thereby enabling the user to apply the fashion images generated based on the conditions input to their own photos or avatars and check specific styling.

[0657] A "user" is an individual who wants to embody the image of a fashion item.

[0658] A "terminal" is an electronic device used by a user, such as a smartphone, PC, or tablet.

[0659] A "server" is a computer system that includes a generation AI and receives user requests and generates images.

[0660] "Generative AI" is an artificial intelligence model that generates fashion images based on conditions entered by the user.

[0661] "Conditions" refer to detailed information and desired characteristics about a fashion item that a user inputs into a terminal.

[0662] "Fashion images" are visual representations of fashion items created by generative AI.

[0663] "Virtual try-on" refers to a user applying a generated fashion image to their own photo or avatar, allowing them to check the look as if they were trying it on.

[0664] The system for implementing this invention is composed of a user, a terminal, and a server. Specifically, the user inputs fashion parameters using a terminal such as a smartphone, and a generation AI generates fashion images based on the parameters. Finally, the system provides a means for the user to virtually try on the images.

[0665] System Program Overview

[0666] First, the user uses the device to input fashion criteria based on their preferences. For example, a condition could be "casual autumn outfit coordination." This input data is converted into an appropriate format (e.g., JSON format) by the device and sent to the server as an HTTP request.

[0667] The server receives requests using a web framework called Flask. The received data is analyzed and condition data is extracted. This condition data is passed to an AI model library (tentative name: some_ai_module). This AI model uses past data and learning models to generate fashion images based on the user's requests.

[0668] The generated fashion image is sent back from the server to the device. The device displays the received fashion image to the user. At this time, the user can virtually try on the generated fashion image. Virtual try-on refers to overlaying the fashion image on the user's photo or avatar, allowing the user to check how the item will look when actually worn.

[0669] Hardware and software used

[0670] Hardware: General cloud servers, smartphones, tablets, etc.

[0671] Software: Flask (web framework), some_ai_module (AI model library)

[0672] Specific examples

[0673] As a specific example, if a user wants to coordinate casual autumn clothing, the user can follow the following steps.

[0674] 1. The user opens the smartphone application interface and enters "Casual Fall Outfit Coordination."

[0675] 2. By pressing the "Send" button, the device converts the input data into JSON format and sends an HTTP POST request to the server.

[0676] 3. The server receives the request and parses and extracts the condition data.

[0677] 4. Use some_ai_module to generate fashion images based on conditions.

[0678] 5. The generated image is sent back from the server to the device.

[0679] 6. The user checks the generated image on the device and tries on the clothes virtually.

[0680] Prompt Sentence Examples

[0681] The user inputs "Casual autumn outfit coordination" as a prompt sentence. Then, the user presses the send button to send the data to the server.

[0682] This allows users to easily create their desired fashion image and check the visual feedback through virtual try-on, making it easier for users to select and purchase more specific fashion items.

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

[0684] Step 1:

[0685] The user inputs fashion criteria using the terminal. For example, the user inputs a criteria such as "casual autumn outfit coordination" into a text field.

[0686] Step 2:

[0687] The user presses the "Submit" button to send the input data from the device to the server, which then converts the input data into an appropriate format (e.g., JSON) and sends it to the server as an HTTP POST request.

[0688] Step 3:

[0689] The server uses Flask to receive HTTP requests from users, which are then parsed in JSON format to extract conditional data.

[0690] Step 4:

[0691] The server prepares the analyzed condition data to be passed to the generation AI. Specifically, it converts the data into the required format so that it can be input to the generation AI.

[0692] Step 5:

[0693] The server inputs condition data into the generation AI (some_ai_module) and generates fashion images. The generation AI uses past data and learning models to generate the optimal fashion images that match the conditions.

[0694] Step 6:

[0695] After the generation AI generates the fashion image, the server receives the generated image data and prepares to send it back to the device in JSON format.

[0696] Step 7:

[0697] The server returns the generated fashion image data to the terminal as an HTTP response.

[0698] Step 8:

[0699] The device analyzes the received fashion image data and displays it to the user, who can then check the displayed image and save or share it as needed.

[0700] Step 9:

[0701] Users can virtually try on the generated fashion images. Specifically, the fashion images are superimposed on the user's photo or avatar, allowing them to see how they will look when actually worn.

[0702] In this way, the user can specifically check and try on the fashion image generated based on the conditions input by the user.

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

[0704] The present invention relates to a system that generates individual fashion images based on user-entered conditions, recognizes the user's emotions, and provides optimal fashion images based on those emotions. This system is composed of components: a user, a terminal, a server, and an emotion engine. The details are described below.

[0705] System configuration

[0706] The system includes the following major components:

[0707] 1. User: An individual who wants to embody the image of a fashion item.

[0708] 2. Device: Electronic devices used by users, such as smartphones, computers, and tablets.

[0709] 3. Server: A computer system that includes a generation AI and receives user requests and performs image generation.

[0710] 4. Emotion engine: Recognizes the user's emotions along with the user's input conditions and performs analysis based on those emotions.

[0711] Program Processing Overview

[0712] The user inputs the specifications for the fashion items through the device, and this information, along with the user's emotional state, is sent to the server. The server uses a generative AI and emotion engine to generate fashion images based on the received specifications and emotional state, and sends the results back to the device. This allows the user to receive specific visuals of the fashion items they desire and suggestions that fit their emotions.

[0713] Program Processing Details

[0714] User Input

[0715] The user opens the device's interface and inputs the desired fashion item, such as an "adult T-shirt" or "Pokémon-style sneakers." As the user inputs the information, the device's camera, microphone, and other sensors capture the user's emotional state (e.g., smile, surprise, sadness, etc.). The user's emotional state and the conditions are then recorded together.

[0716] Input data formatting and transmission

[0717] The device analyzes the user's input data and emotional state, converts it into an appropriate format (e.g., JSON), and sends it to the server as an HTTP POST request.

[0718] Data reception and analysis on the server

[0719] The server receives requests sent from the device and analyzes the input data and emotional state. Conditions and emotional states are extracted from the analyzed data and prepared for passing to the generative AI and emotion engine.

[0720] Image generation with generative AI and emotion engine

[0721] The server passes the conditions to the generation AI and the emotional state to the emotion engine. The emotion engine adjusts the output of the generation AI based on the emotional state. The generation AI generates fashion images that match the conditions and adjusts the optimal design, color, and style based on the emotion.

[0722] Returning images

[0723] The generated fashion image and associated metadata (e.g., size, color, and material information) are sent back from the server to the device as an HTTP response.

[0724] Displaying an image to the user

[0725] The device analyzes the image data received from the server and displays it to the user, who can then view the image and save or share it as needed.

[0726] Specific use cases

[0727] Example 1: Generating images of adult T-shirts

[0728] 1. The user types "adult T-shirt" into the device interface, and the camera simultaneously captures the user's smile.

[0729] 2. The device converts the input data and emotional state ("smile") into JSON format and sends an HTTP request to the server.

[0730] 3. The server receives this request and passes the condition "adult T-shirt" and the emotional state "smiling" to the generation AI and emotion engine.

[0731] 4. Generative AI generates images of T-shirts with simple and sophisticated designs, while the emotion engine suggests brighter colors and more cheerful designs.

[0732] 5. The server sends the adjusted image back to the device.

[0733] 6. The terminal displays the received image to the user, who confirms it.

[0734] Example 2: Image generation of Pokémon-style sneakers

[0735] 1. The user types "Pokémon-style sneakers" into the device interface, and the microphone simultaneously captures the user's excited voice.

[0736] 2. The device converts the input data and emotional state ("excitement") into JSON format and sends an HTTP request to the server.

[0737] 3. The server receives this request and passes the condition "Pokémon-style sneakers" and the emotional state "excited" to the generation AI and emotion engine.

[0738] 4. The generative AI generates images of sneakers based on Pokémon characters, and the emotion engine adjusts the designs to be more eye-catching and vibrant in color.

[0739] 5. The server sends the adjusted image back to the device.

[0740] 6. The terminal displays the received image to the user, who confirms it.

[0741] This system allows users to easily obtain fashion images that match their preferences, and also allows them to receive suggestions that suit their emotions at the time. The use of an emotion engine effectively solves the problems that arise in conventional search systems, improving the user experience.

[0742] The processing flow will be explained below.

[0743] Step 1:

[0744] The user opens the device's interface and inputs the desired fashion item, such as "adult T-shirt" or "Pokémon-style sneakers," into a text field. The device's camera and microphone also collect emotional data, such as the user's facial expressions and voice.

[0745] Step 2:

[0746] The user presses the "Send" button.

[0747] Step 3:

[0748] The device receives the user's input and emotion data and converts it into JSON format. For example, it generates the following JSON data:

[0749] json

[0750] {

[0751] "query": "adult t-shirt",

[0752] "emotion": "smile"

[0753] }

[0754] Step 4:

[0755] The device sets this JSON data as the body of an HTTP POST request and sends it to the server.

[0756] Step 5:

[0757] The server receives an HTTP POST request from the terminal.

[0758] Step 6:

[0759] The server parses the received JSON data and extracts the condition (in this case, "adult T-shirt") from the "query" field and the emotional state (in this case, "smiling") from the "emotion" field.

[0760] Step 7:

[0761] The conditions extracted by the server are input into the generation AI, and the emotional state is input into the emotion engine.

[0762] Step 8:

[0763] The server passes the conditions to the generation AI and requests it to generate a fashion image. At the same time, it passes the emotional state to the emotion engine and requests it to perform emotion-based analysis.

[0764] Step 9:

[0765] The generative AI generates fashion images based on the received conditions, and then references past data and learning models to create the optimal image.

[0766] Step 10:

[0767] The emotion engine adjusts the generated fashion image based on the user's emotional state, for example, adjusting the design to favor bright colors and a lively style if the emotional state is "smiling."

[0768] Step 11:

[0769] The server formats the generated fashion images and associated metadata (e.g., color, size, and material information) into JSON format.

[0770] Step 12:

[0771] The server sends the formatted response data to the terminal as an HTTP response.

[0772] Step 13:

[0773] The terminal receives an HTTP response from the server.

[0774] Step 14:

[0775] The terminal analyzes the response data, decodes the image data, and displays it on the screen.

[0776] Step 15:

[0777] The user can view the fashion images displayed on their device, and can save or share these images.

[0778] The above is a detailed description of each step from processing user input and emotion data to displaying fashion images.

[0779] Example 2

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

[0781] Conventional fashion image generation systems generate images based only on the user's desired conditions, and therefore do not provide suggestions that reflect the emotional state of each individual user. This makes it difficult to increase user satisfaction. Furthermore, the process of formatting the user's input data, sending it to the server, and analyzing it is inefficient, making it difficult to respond in real time. There is a need for a system that can propose appropriate fashion images based on the user's individual emotional state.

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

[0783] In this invention, the server includes means for generating individual fashion images based on conditions and emotional state input by a user and providing the generated images to the user, means for receiving the conditions and emotional state input by the user to a terminal, means for the terminal to format the conditions and emotional state into an appropriate data format and transmit the data to the server, means for the server to analyze the received data and extract the conditions and emotional state, means for generating fashion images using a generative AI model based on the conditions and adjusting the fashion images generated by an emotion engine based on the emotional state, means for returning the generated and adjusted fashion images to the terminal, and means for the terminal to display the generated and adjusted fashion images to the user. This enables more personalized fashion images to be proposed according to the user's emotional state, thereby increasing user satisfaction.

[0784] A "user" is an individual who wants to embody the image of a fashion item.

[0785] A "terminal" is an electronic device used by a user, such as a smartphone, PC, or tablet.

[0786] "Conditions" are information that indicates specific requirements or features of the fashion item desired by the user.

[0787] "Emotional state" is information that indicates the user's psychological and emotional state at any given time.

[0788] The "receiving means" includes mechanisms and functions for acquiring the conditions and emotional states input by the user to the terminal.

[0789] The "formatting means" has the function of converting the conditions and emotional state input by the user into an appropriate data format.

[0790] The "transmission means" includes a mechanism and a protocol for transmitting the data converted by the formatting means to the server.

[0791] The "analysis means" has the function of analyzing the data received by the server and extracting the condition and emotional state.

[0792] A "generative AI model" is an artificial intelligence model used to generate fashion images based on input conditions.

[0793] An "emotional engine" includes mechanisms and algorithms for adjusting the generated fashion image based on the user's emotional state.

[0794] The "returning means" includes mechanisms and protocols for returning the generated and adjusted fashion images to the terminal.

[0795] The "display means" has a mechanism and function for visually presenting the received fashion image to the user.

[0796] The present invention relates to a system that generates and provides individual fashion images to users based on conditions and emotional states input by the user. The system is composed of components including a user, a terminal, a server, and an emotion engine.

[0797] System Configuration

[0798] User

[0799] A user is an individual who wants to embody the image of a fashion item, and is a user of the system.

[0800] Terminal

[0801] The device is an electronic device used by the user, such as a smartphone, PC, tablet, etc. The user inputs conditions through the device, and the emotional state is acquired using sensors such as a camera and microphone.

[0802] server

[0803] The server is a computer system that contains the generative AI model and emotion engine and processes user requests. The server receives user input data, analyzes it, and performs the necessary processing.

[0804] Emotion Engine

[0805] The emotion engine is a software component for analyzing the user's emotional state and adjusting the generated fashion image based on that information.

[0806] Program Processing Details

[0807] User Input

[0808] The user opens the device's interface and inputs the desired fashion item, such as an "adult T-shirt" or "Pokémon-style sneakers." As the user inputs the information, the device's camera, microphone, and other sensors capture the user's emotional state (e.g., smile, surprise, sadness, etc.). These conditions and the emotional state are then recorded.

[0809] Input data formatting and transmission

[0810] The device analyzes the user's input data and emotional state, converts it into an appropriate data format (e.g., JSON), and then sends this data to the server as an HTTP POST request.

[0811] Data reception and analysis on the server

[0812] The server receives the HTTP POST request sent from the device and analyzes the input data and emotional state. The analyzed data is separated into conditions and emotional states, and is ready to be passed to the generative AI and emotion engine.

[0813] Image generation with generative AI and emotion engine

[0814] The server sends the user's input conditions (such as "adult T-shirt" or "Pokémon-style sneakers") to the generative AI model, and sends the user's emotional data (such as "smile" or "excitement") to the emotion engine. The generative AI generates fashion images that match the conditions, and the emotion engine adjusts the generated images appropriately based on the user's emotional state.

[0815] Returning and viewing images

[0816] The generated fashion image and related metadata (size, color, material information, etc.) are sent back from the server to the device as an HTTP response. The device analyzes the received image data and displays it in the user's interface. The user can then view the displayed image and save or share it as desired.

[0817] Specific use cases

[0818] Example 1: Generating images of adult T-shirts

[0819] 1. The user types "adult T-shirt" into the device interface, and the camera simultaneously captures the user's smile.

[0820] 2. The device converts the input data and emotional state ("smile") into JSON format and sends an HTTP request to the server.

[0821] 3. The server receives this request and passes the condition "adult T-shirt" and the emotional state "smiling" to the generative AI model and emotion engine.

[0822] 4. The generative AI model generates images of T-shirts with simple and sophisticated designs, while the emotion engine suggests brighter colors and more cheerful designs.

[0823] 5. The server sends the adjusted image back to the device.

[0824] 6. The terminal displays the received image to the user, who confirms it.

[0825] Example 2: Image generation of Pokémon-style sneakers

[0826] 1. The user types "Pokémon-style sneakers" into the device interface, and the microphone simultaneously captures the user's excited voice.

[0827] 2. The device converts the input data and emotional state ("excitement") into JSON format and sends an HTTP request to the server.

[0828] 3. The server receives this request and passes the condition "Pokémon-style sneakers" and the emotional state "excited" to the generative AI model and emotion engine.

[0829] 4. The generative AI model generates images of sneakers featuring Pokémon characters, and the emotion engine adjusts for more eye-catching designs and vibrant colors.

[0830] 5. The server sends the adjusted image back to the device.

[0831] 6. The terminal displays the received image to the user, who confirms it.

[0832] Prompt Sentence Examples

[0833] For adult t-shirt production:

[0834] "Generate simple yet sophisticated t-shirt designs for adults. Users smile."

[0835] To create Pokémon-style sneakers:

[0836] "Generate sneakers with eye-catching designs and vibrant colors featuring Pokémon characters. Users are super excited."

[0837] This system allows users to easily obtain fashion images that match their preferences and emotions, and enjoy a more personalized experience. The use of an emotion engine solves the issues that existed in conventional search systems, dramatically improving the user experience.

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

[0839] Step 1:

[0840] The user opens the interface using a device and inputs the conditions for the desired fashion item. Specifically, they enter "adult T-shirt" or "Pokémon-style sneakers" into the device's input field. At the same time, the device's camera and microphone are used to detect the user's emotional state (e.g., smiling, excited). The conditions and emotional state are obtained as input data.

[0841] Step 2:

[0842] The device receives and analyzes the user's input data (conditions and emotional state). Specifically, it analyzes sensor data from the camera and microphone to obtain emotional states such as smiles and excitement. It then converts this data into JSON format. The input is the user's condition and emotional state data, and the output is the data converted into JSON format.

[0843] Step 3:

[0844] The terminal sends the converted data to the server as an HTTP POST request. At this time, the endpoint URL of the server to which the data is to be sent is used. The input is the data converted to JSON format, and the output is the HTTP request sent to the server.

[0845] Step 4:

[0846] The server receives an HTTP POST request sent from the device. The received data is analyzed to separate the conditions and emotional state entered by the user. The input is the HTTP request data, and the output is the analyzed conditions and emotional state.

[0847] Step 5:

[0848] Based on the analyzed data, the server sends conditions to the generative AI model and emotional states to the emotion engine. The generative AI model generates an initial fashion image based on the conditions, and the emotion engine adjusts this image based on the emotional state. The input is the conditions and emotional state, and the output is the generated and adjusted fashion image.

[0849] Step 6:

[0850] The server returns the generated and adjusted fashion images and related metadata (size, color, material information, etc.) to the device as an HTTP response. The input is the generated and adjusted image data, and the output is the HTTP response to the device.

[0851] Step 7:

[0852] The device analyzes the fashion image data received from the server and displays it on the user's interface, allowing the user to check the generated image and save or share it. The input is the image data received as an HTTP response, and the output is the display to the user.

[0853] (Application example 2)

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

[0855] In the modern fashion industry, users have to make a lot of effort to narrow down their choices from a wide variety of items. Furthermore, conventional fashion image generation systems lack personalized suggestions based on the user's emotions, making it difficult to find outfits that fit the user's actual needs and mood. In particular, in virtual stores, it is necessary to provide more appropriate fashion suggestions based on emotions when users virtually try on clothes.

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

[0857] In this invention, the server includes means for receiving conditions input to the terminal by the user, means for generating fashion images using a generation AI based on the conditions, means for returning the generated fashion images to the terminal, means for detecting the user's emotions using an emotion recognition engine, means for adjusting the output of the generation AI based on the detected emotions, and means for displaying the adjusted fashion images on the terminal. This allows users to easily obtain fashion images that suit their emotions and moods, and to find the optimal coordination that fits their emotions in a virtual store.

[0858] A "user" refers to an individual who wishes to embody a fashion image.

[0859] "Terminal" refers to electronic devices used by users, such as smartphones, personal computers, and tablets.

[0860] "Conditions" refer to the desires and requests regarding fashion items that a user inputs into the terminal.

[0861] "Generative AI" refers to artificial intelligence that generates new fashion images based on conditions entered by the user.

[0862] "Fashion image" refers to the visual of a specific fashion item generated by generative AI.

[0863] An "emotion recognition engine" is an engine that detects and analyzes user emotions and provides data to adjust the output of generative AI.

[0864] "Server" refers to the central computer system that receives and processes user input data and emotion data.

[0865] "Means for receiving" refers to the function by which the server receives the conditions and emotion data sent from the terminal.

[0866] "Means for generation" refers to the function by which the generative AI creates fashion images based on the received conditions.

[0867] "Means for sending back" refers to the function of sending back the generated fashion image from the server to the terminal.

[0868] "Means for detecting" refers to a function for recognizing a user's emotions and analyzing their emotional state.

[0869] "Adjustment means" refers to a function for optimizing the output of the generative AI based on the emotions detected by the emotion recognition engine.

[0870] "Display means" refers to a function that visually presents the fashion images received by the terminal from the server to the user.

[0871] This invention is a system that generates individual fashion images based on user-entered conditions, recognizes the user's emotions, and provides optimal fashion images based on those emotions. This system consists of a user, a terminal, a server, an emotion recognition engine, and a generation AI model.

[0872] System configuration

[0873] The system includes the following major components:

[0874] 1. User: An individual who wants to embody the image of a fashion item.

[0875] 2. Device: Electronic devices used by users, such as smartphones, computers, and tablets.

[0876] 3. Server: A computer system that includes a generation AI and receives user requests and performs image generation.

[0877] 4. Emotion recognition engine: Recognizes the user's emotions along with the user's input conditions and performs analysis based on those emotions.

[0878] System Operation Overview

[0879] Users input their desired fashion item preferences through their device, and this information, along with the user's emotional state, is sent to the server. The server then uses a generative AI and emotion recognition engine to generate fashion images based on the received preferences and emotional state, and sends the results back to the device. This allows users to receive specific visuals of their desired fashion items and suggestions that fit their emotions.

[0880] Detailed explanation of program processing

[0881] First, the user inputs the desired fashion items into the device interface. At the same time, the user's emotional state is also captured through sensors such as the device's camera and microphone. This information is converted into an appropriate format and sent to the server as an HTTP request.

[0882] The server receives this request and analyzes the input data and emotional data. Conditions and emotional states are extracted from the analyzed data and passed to the generation AI and emotion recognition engine. The generation AI generates fashion images that fit the conditions, and the emotion recognition engine adjusts them based on the emotional state. The generated fashion images are then sent back to the device from the server along with related metadata.

[0883] Hardware and software used

[0884] The system uses the following hardware and software:

[0885] Smartphones, computers, tablets, etc.: the devices through which users interact with the interface.

[0886] Emotion recognition engine: An engine for analyzing user emotions.

[0887] Generative AI model: An artificial intelligence model for generating fashion images.

[0888] HTTP request processing library: A software tool for sending and receiving data.

[0889] Specific examples

[0890] For example, if a user inputs "rock-style jacket" into the device interface and the camera captures an excited expression, the server receives the criteria "rock-style jacket" and the emotional state of "excited." The generative AI generates a rock-style jacket, and the emotion recognition engine suggests more flashy designs and dynamic colors. The final image is sent back to the user for review.

[0891] Example prompt sentence:

[0892] "Fashion item: Rock style jacket, Emotion: Excitement"

[0893] This allows users to receive personalized fashion suggestions based on their emotions.

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

[0895] Step 1:

[0896] The user opens the device interface and inputs the desired fashion item. For example, they might type "rock style jacket" into a text box. The device's camera and microphone also capture the user's emotional state (e.g., smile, surprise, excitement). The input data and emotional data are collected and stored on the device.

[0897] Input: A condition about a fashion item ("rock-style jacket") and the user's emotional state ("excitement")

[0898] Output: Input data and emotion data collected and saved on the device

[0899] Step 2:

[0900] The device converts the collected user input data and emotion data into an appropriate format (e.g., JSON format) and sends it to the server as an HTTP POST request. This data includes the user's desired fashion item conditions and emotional state.

[0901] Input: Input data and emotion data stored on the device

[0902] Output: HTTP POST request sent to the server

[0903] Step 3:

[0904] The server receives the HTTP POST request sent from the device, analyzes the data, extracts conditions and emotional states from the received data, and prepares the data for passing to the generative AI model and emotion recognition engine.

[0905] Input: HTTP POST request sent from the terminal

[0906] Output: Input data to the generative AI model and emotion recognition engine

[0907] Step 4:

[0908] The generative AI model generates fashion images based on the condition data it receives. Furthermore, the emotion recognition engine adjusts the output of the generative AI model based on the emotional state data it receives. For example, if the emotion is "excited," it adjusts the design and color to be more flashy and dynamic.

[0909] Input: Condition data for generative AI models, and emotional state data for emotion recognition engines

[0910] Output: Adjusted fashion image

[0911] Step 5:

[0912] The server returns the adjusted fashion image obtained from the generative AI model and emotion recognition engine, along with related metadata (e.g., size, color, and material information), to the device as an HTTP response.

[0913] Input: Adjusted fashion images and associated metadata

[0914] Output: HTTP response to the device

[0915] Step 6:

[0916] The device analyzes the HTTP response received from the server and displays the fashion image to the user, who can then check the displayed image and save or share it as needed.

[0917] Input: HTTP response received from the server

[0918] Output: Fashion images displayed to the user

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

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

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

[0922] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0935] This invention relates to a system that uses generative AI to generate fashion images based on conditions entered by a user. This system is composed of elements including a user, a terminal, and a server, and is described in detail below.

[0936] System configuration

[0937] The system includes the following major components:

[0938] 1. User: An individual who wants to embody the image of a fashion item.

[0939] 2. Device: Electronic devices used by users, such as smartphones, computers, and tablets.

[0940] 3. Server: A computer system that includes a generation AI and receives user requests and performs image generation.

[0941] Program Processing Overview

[0942] Users input the specifications for the fashion items they are looking for through their device, and this information is sent to the server. The server uses generative AI to generate fashion images based on the received specifications and sends the results back to the device. This allows users to obtain specific visuals of the fashion items they desire.

[0943] Program Processing Details

[0944] User Input

[0945] Users open a dedicated interface on their device and enter the desired fashion items, such as "adult T-shirts" or "Pokémon-style sneakers." Once the input is complete, the data is sent by clicking the "Send" button.

[0946] Input data formatting and transmission

[0947] The device parses the user's input data, converts it into an appropriate format (e.g., JSON), and sends it to the server as an HTTP POST request.

[0948] Data reception and analysis on the server

[0949] The server receives the request sent from the device and analyzes the input data. Conditions are extracted from the analyzed data and prepared for passing to the generation AI.

[0950] Image generation by generative AI

[0951] The server passes the analysis results to the generation AI as input data. Based on this, the generation AI generates fashion images that match the conditions. The generation AI uses past data and learning models to create the optimal image.

[0952] Returning images

[0953] The generated fashion image and associated metadata (e.g., size, color, and material information) are sent back to the terminal as an HTTP response from the server.

[0954] Displaying an image to the user

[0955] The device analyzes the image data received from the server and displays it to the user, who can then view the image and save or share it as needed.

[0956] Specific use cases

[0957] Example 1: Generating images of adult T-shirts

[0958] 1. The user enters "adult T-shirt" into the device interface and presses the "Send" button.

[0959] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[0960] 3. The server receives this request and passes the condition "adult T-shirt" to the generation AI.

[0961] 4. The generative AI generates an image of a T-shirt with a simple yet sophisticated design and sends it back to the server.

[0962] 5. The server sends the generated image back to the device.

[0963] 6. The terminal displays the received image to the user, who confirms it.

[0964] Example 2: Image generation of Pokémon-style sneakers

[0965] 1. The user types "Pokémon-style sneakers" into the device interface and presses the "Send" button.

[0966] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[0967] 3. The server receives this request and passes the condition "Pokémon-style sneakers" to the generation AI.

[0968] 4. The generation AI generates an image of a sneaker featuring a Pokémon character and sends it back to the server.

[0969] 5. The server sends the generated image back to the device.

[0970] 6. The terminal displays the received image to the user, who confirms it.

[0971] This system allows users to easily obtain fashion images that suit their preferences, effectively resolving the problems that have arisen with conventional search systems.

[0972] The processing flow will be explained below.

[0973] Step 1:

[0974] The user opens the device interface and inputs the desired fashion item, such as "adult T-shirt" or "Pokémon-style sneakers," into a text field.

[0975] Step 2:

[0976] The user presses the "Send" button.

[0977] Step 3:

[0978] The terminal takes the user's input and converts it to JSON format, for example generating the following JSON data:

[0979] json

[0980] {

[0981] "query": "adult t-shirts"

[0982] }

[0983] Step 4:

[0984] The device sets this JSON data as the body of an HTTP POST request and sends it to the server.

[0985] Step 5:

[0986] The server receives an HTTP POST request from the terminal.

[0987] Step 6:

[0988] The server parses the received JSON data and extracts the condition (in this case, "adult T-shirts") from the "query" field.

[0989] Step 7:

[0990] The conditions extracted by the server are set as input data for the generation AI.

[0991] Step 8:

[0992] The server passes the conditions to the generation AI and requests it to generate a fashion image.

[0993] Step 9:

[0994] The generative AI generates fashion images based on the received conditions, where it references its internal model and past data to create the optimal image.

[0995] Step 10:

[0996] The generated AI sends the generated fashion image back to the server.

[0997] Step 11:

[0998] The server formats the received fashion images and associated metadata (e.g., color, size, and material information) into JSON format.

[0999] Step 12:

[1000] The server sends the formatted response data to the terminal as an HTTP response.

[1001] Step 13:

[1002] The terminal receives an HTTP response from the server.

[1003] Step 14:

[1004] The terminal analyzes the response data, decodes the image data, and displays it on the screen.

[1005] Step 15:

[1006] The user can view the fashion images displayed on their device, and can save or share these images.

[1007] The above is a detailed description of each step from user input to display of a fashion image.

[1008] Example 1

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

[1010] Conventional search systems have the problem that it is difficult for users to see specific visuals of the fashion items they want, and the sheer volume of search results means it takes a long time for users to find the information they are looking for. Even if users input their desired criteria, there are limited ways to obtain specific images based on those criteria. To solve these problems, a system is needed that allows users to easily obtain the fashion images they desire.

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

[1012] In this invention, the server includes means for the terminal to analyze user input data and convert it into an appropriate format, means for transmitting the formatted data to the server, means for the server to receive the formatted data, means for the server to analyze the received data and extract conditions, means for generating fashion images using a generative AI model based on the conditions, means for returning the generated fashion images to the terminal, and means for the terminal to analyze the image data received and display it to the user. This makes it possible for the user to easily and quickly obtain specific fashion images based on the conditions desired.

[1013] "User input" refers to the act of an individual using the system inputting the conditions relating to the fashion item they desire into the terminal interface.

[1014] A "terminal" is an electronic device used by a user, such as a smartphone, PC, or tablet, and is a device that receives user input and communicates with a server.

[1015] The "server" is a computer system that includes a generative AI model, receives and analyzes user input data, generates fashion images based on the conditions, and returns them to the terminal.

[1016] A "generative AI model" is an artificial intelligence algorithm that uses past data and learning models to generate fashion images that match received conditions.

[1017] A "prompt" is an instruction sentence input into a generative AI model, which includes the conditions for generating a specific fashion image.

[1018] An "HTTP POST request" is one of the communication protocols used by a terminal to send data to a server, and includes formatted input data as a request body.

[1019] "Formatting" is the process of converting the data entered by the user into a form that is easy to handle within the system (for example, JSON format).

[1020] "Data analysis" is the process of examining the data received by the server in detail, extracting conditions, and preparing it in the format required for subsequent processing.

[1021] A "user interface" is a screen or input form that allows a user to operate a system, and is used when making user input.

[1022] "Image generation" is the process by which a generative AI model creates a fashion image based on user input.

[1023] "Metadata" is additional information associated with the generated fashion image, including, for example, size, color, material, etc.

[1024] This invention relates to a system that uses a generative AI model to generate fashion images based on user-entered conditions. This system is composed of the following elements: a user, a terminal, and a server.

[1025] System configuration

[1026] The system includes the following main components:

[1027] 1. User: An individual who wants to embody the image of a fashion item.

[1028] 2. Terminal: An electronic device used by a user, such as a smartphone, PC, or tablet. It is a device that receives user input and communicates with a server.

[1029] 3. Server: A computer system that contains the generative AI model, receives user requests, and performs image generation.

[1030] Program Processing Overview

[1031] Users input the specifications for the fashion items they are looking for through their device, and this information is sent to the server. The server uses a generative AI model to generate fashion images based on the received specifications and sends the results back to the device. This allows users to obtain specific visuals of the fashion items they desire.

[1032] Hardware and software usage

[1033] In this system, devices such as smartphones, PCs, and tablets are used, and the server is a computer system with high-performance computing capabilities. The generative AI model uses software frameworks with deep learning algorithms (e.g., TensorFlow, PyTorch, etc.). Communication between the device and server is via the HTTP protocol, with data being sent and received in JSON format.

[1034] Specific use cases

[1035] Example 1: Generating images of adult T-shirts

[1036] 1. The user enters "adult T-shirt" into the device interface and presses the "Send" button.

[1037] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[1038] 3. The server receives this request and passes the condition "adult T-shirt" to the generative AI model.

[1039] 4. The generative AI model generates an image of a T-shirt with a simple yet sophisticated design and sends it back to the server.

[1040] 5. The server sends the generated image back to the device.

[1041] 6. The terminal displays the received image to the user, who confirms it.

[1042] Example prompt:

[1043] "Create simple yet sophisticated adult T-shirt designs."

[1044] Example 2: Image generation of Pokémon-style sneakers

[1045] 1. The user types "Pokémon-style sneakers" into the device interface and presses the "Send" button.

[1046] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[1047] 3. The server receives this request and passes the condition "Pokémon-style sneakers" to the generative AI model.

[1048] 4. The generative AI model generates images of sneakers featuring Pokémon characters and sends them back to the server.

[1049] 5. The server sends the generated image back to the device.

[1050] 6. The terminal displays the received image to the user, who confirms it.

[1051] Example prompt:

[1052] "Generate unique sneaker designs featuring Pokémon characters."

[1053] This system allows users to easily obtain fashion images that match their preferences, effectively resolving the problems that have arisen with conventional search systems. Specifically, it provides a means to resolve the problem of the large number of search results, which make it take a long time to find the desired information, and the problem of not being able to obtain a specific visual image.

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

[1055] Step 1: User input

[1056] The user uses the device interface (smartphone app or web browser) to input the desired fashion item. Specifically, the user enters a condition such as "adult T-shirt" into a text box on the screen and clicks the "Submit" button. This input data triggers the next processing step.

[1057] Input: Conditions for the desired fashion item (e.g., "Adult T-shirt")

[1058] Output: User condition input data (e.g. "Adult T-shirt")

[1059] Step 2: Convert input data format

[1060] The terminal analyzes the condition data entered by the user and converts it into a format that is easy to handle within the system. In this case, the data is converted into JSON format.

[1061] Input: User condition input data (e.g. "Adult T-shirt")

[1062] Data Calculation: Convert condition data to JSON format (e.g., {"item": "Adult T-shirt"})

[1063] Output: Formatted JSON data (e.g., {"item": "Adult T-shirt"})

[1064] Specific operation: The format conversion function on the terminal is executed.

[1065] Step 3: Sending formatted data

[1066] The terminal sends the formatted data to the server as an HTTP POST request.

[1067] Input: Formatted JSON data (e.g., {"item": "Adult T-shirt"})

[1068] Data calculation: Send data in the body of the HTTP request

[1069] Output: HTTP request sent

[1070] Specific operation: The device sends an HTTP POST request to the specified endpoint on the server.

[1071] Step 4: Receiving data on the server

[1072] The server receives the HTTP POST request sent from the terminal and extracts data from the received request body.

[1073] Input: HTTP request (including formatted JSON data)

[1074] Data operation: Extract data from the request body (e.g., {"item": "Adult T-shirt"})

[1075] Output: Extracted JSON data

[1076] Specific behavior: The receiving endpoint on the server detects the request and executes the data extraction function.

[1077] Step 5: Data analysis and condition extraction

[1078] The server analyzes the received data and extracts the conditions entered by the user. During the analysis stage, it also checks the consistency of the data.

[1079] Input: Extracted JSON data (e.g., {"item": "Adult T-shirt"})

[1080] Data calculation: Analysis and extraction of conditional data (e.g., item name "Adult T-shirt")

[1081] Output: Extracted condition data (e.g. "Adult T-shirts")

[1082] Specific operation: The server's data analysis module analyzes the data and extracts conditions.

[1083] Step 6: Image generation using generative AI

[1084] The server inputs the extracted condition data into the generative AI model and issues instructions for generating fashion images. The generative AI model uses past data and learning models to generate fashion images that match the requested conditions.

[1085] Input: Condition data (e.g. "Adult T-shirts")

[1086] Data calculation: Input as a prompt to the generative AI model (e.g., "A simple and sophisticated T-shirt for adults")

[1087] Output: Generated fashion images

[1088] Specific operation: The server passes the prompt sentence to the generative AI model, and the image generation function is executed.

[1089] Step 7: Sending the image from the server back to the device

[1090] The fashion image generated by the generative AI and its associated metadata are sent back to the device from the server as an HTTP response.

[1091] Input: Generated fashion images and metadata

[1092] Data operations: Reconstruct data into a response format (e.g., {"image": "base64-encoded-image", "size": "L", "color": "blue", "material": "cotton"})

[1093] Output: HTTP response

[1094] Specific operation: The server constructs response data and sends it to the terminal as an HTTP response.

[1095] Step 8: Displaying the image to the user

[1096] The device receives the HTTP response from the server, analyzes the image data, and displays it to the user, who can then check the final image of the fashion item.

[1097] Input: HTTP response (including image data and metadata)

[1098] Data calculation: Analysis of response data

[1099] Output: The image displayed in the user interface

[1100] Specific operation: The device analyzes the response and displays the image data on the screen.

[1101] (Application example 1)

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

[1103] To provide a system for generating fashion images based on conditions input by a user, with a means for enabling a user to try on and check the generated fashion images, thereby enabling the user to easily obtain specific visual feedback that cannot be obtained by a normal search system.

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

[1105] In this invention, the server includes means for generating individual fashion images based on conditions input by the user and means for allowing the user to virtually try on the generated fashion images, thereby enabling the user to apply the fashion images generated based on the conditions input to their own photos or avatars and check specific styling.

[1106] A "user" is an individual who wants to embody the image of a fashion item.

[1107] A "terminal" is an electronic device used by a user, such as a smartphone, PC, or tablet.

[1108] A "server" is a computer system that includes a generation AI and receives user requests and generates images.

[1109] "Generative AI" is an artificial intelligence model that generates fashion images based on conditions entered by the user.

[1110] "Conditions" refer to detailed information and desired characteristics about a fashion item that a user inputs into a terminal.

[1111] "Fashion images" are visual representations of fashion items created by generative AI.

[1112] "Virtual try-on" refers to a user applying a generated fashion image to their own photo or avatar, allowing them to check the look as if they were trying it on.

[1113] The system for implementing this invention is composed of a user, a terminal, and a server. Specifically, the user inputs fashion parameters using a terminal such as a smartphone, and a generation AI generates fashion images based on the parameters. Finally, the system provides a means for the user to virtually try on the images.

[1114] System Program Overview

[1115] First, the user uses the device to input fashion criteria based on their preferences. For example, a condition could be "casual autumn outfit coordination." This input data is converted into an appropriate format (e.g., JSON format) by the device and sent to the server as an HTTP request.

[1116] The server receives requests using a web framework called Flask. The received data is analyzed and condition data is extracted. This condition data is passed to an AI model library (tentative name: some_ai_module). This AI model uses past data and learning models to generate fashion images based on the user's requests.

[1117] The generated fashion image is sent back from the server to the device. The device displays the received fashion image to the user. At this time, the user can virtually try on the generated fashion image. Virtual try-on refers to overlaying the fashion image on the user's photo or avatar, allowing the user to check how the item will look when actually worn.

[1118] Hardware and software used

[1119] Hardware: General cloud servers, smartphones, tablets, etc.

[1120] Software: Flask (web framework), some_ai_module (AI model library)

[1121] Specific examples

[1122] As a specific example, if a user wants to coordinate casual autumn clothing, the user can follow the following steps.

[1123] 1. The user opens the smartphone application interface and enters "Casual Fall Outfit Coordination."

[1124] 2. By pressing the "Send" button, the device converts the input data into JSON format and sends an HTTP POST request to the server.

[1125] 3. The server receives the request and parses and extracts the condition data.

[1126] 4. Use some_ai_module to generate fashion images based on conditions.

[1127] 5. The generated image is sent back from the server to the device.

[1128] 6. The user checks the generated image on the device and tries on the clothes virtually.

[1129] Prompt Sentence Examples

[1130] The user inputs "Casual autumn outfit coordination" as a prompt sentence. Then, the user presses the send button to send the data to the server.

[1131] This allows users to easily create their desired fashion image and check the visual feedback through virtual try-on, making it easier for users to select and purchase more specific fashion items.

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

[1133] Step 1:

[1134] The user inputs fashion criteria using the terminal. For example, the user inputs a criteria such as "casual autumn outfit coordination" into a text field.

[1135] Step 2:

[1136] The user presses the "Submit" button to send the input data from the device to the server, which then converts the input data into an appropriate format (e.g., JSON) and sends it to the server as an HTTP POST request.

[1137] Step 3:

[1138] The server uses Flask to receive HTTP requests from users, which are then parsed in JSON format to extract conditional data.

[1139] Step 4:

[1140] The server prepares the analyzed condition data to be passed to the generation AI. Specifically, it converts the data into the required format so that it can be input to the generation AI.

[1141] Step 5:

[1142] The server inputs condition data into the generation AI (some_ai_module) and generates fashion images. The generation AI uses past data and learning models to generate the optimal fashion images that match the conditions.

[1143] Step 6:

[1144] After the generation AI generates the fashion image, the server receives the generated image data and prepares to send it back to the device in JSON format.

[1145] Step 7:

[1146] The server returns the generated fashion image data to the terminal as an HTTP response.

[1147] Step 8:

[1148] The device analyzes the received fashion image data and displays it to the user, who can then check the displayed image and save or share it as needed.

[1149] Step 9:

[1150] Users can virtually try on the generated fashion images. Specifically, the fashion images are superimposed on the user's photo or avatar, allowing them to see how they will look when actually worn.

[1151] In this way, the user can specifically check and try on the fashion image generated based on the conditions input by the user.

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

[1153] The present invention relates to a system that generates individual fashion images based on user-entered conditions, recognizes the user's emotions, and provides optimal fashion images based on those emotions. This system is composed of components: a user, a terminal, a server, and an emotion engine. The details are described below.

[1154] System configuration

[1155] The system includes the following major components:

[1156] 1. User: An individual who wants to embody the image of a fashion item.

[1157] 2. Device: Electronic devices used by users, such as smartphones, computers, and tablets.

[1158] 3. Server: A computer system that includes a generation AI and receives user requests and performs image generation.

[1159] 4. Emotion engine: Recognizes the user's emotions along with the user's input conditions and performs analysis based on those emotions.

[1160] Program Processing Overview

[1161] The user inputs the specifications for the fashion items through the device, and this information, along with the user's emotional state, is sent to the server. The server uses a generative AI and emotion engine to generate fashion images based on the received specifications and emotional state, and sends the results back to the device. This allows the user to receive specific visuals of the fashion items they desire and suggestions that fit their emotions.

[1162] Program Processing Details

[1163] User Input

[1164] The user opens the device's interface and inputs the desired fashion item, such as an "adult T-shirt" or "Pokémon-style sneakers." As the user inputs the information, the device's camera, microphone, and other sensors capture the user's emotional state (e.g., smile, surprise, sadness, etc.). The user's emotional state and the conditions are then recorded together.

[1165] Input data formatting and transmission

[1166] The device analyzes the user's input data and emotional state, converts it into an appropriate format (e.g., JSON), and sends it to the server as an HTTP POST request.

[1167] Data reception and analysis on the server

[1168] The server receives requests sent from the device and analyzes the input data and emotional state. Conditions and emotional states are extracted from the analyzed data and prepared for passing to the generative AI and emotion engine.

[1169] Image generation with generative AI and emotion engine

[1170] The server passes the conditions to the generation AI and the emotional state to the emotion engine. The emotion engine adjusts the output of the generation AI based on the emotional state. The generation AI generates fashion images that match the conditions and adjusts the optimal design, color, and style based on the emotion.

[1171] Returning images

[1172] The generated fashion image and associated metadata (e.g., size, color, and material information) are sent back from the server to the device as an HTTP response.

[1173] Displaying an image to the user

[1174] The device analyzes the image data received from the server and displays it to the user, who can then view the image and save or share it as needed.

[1175] Specific use cases

[1176] Example 1: Generating images of adult T-shirts

[1177] 1. The user types "adult T-shirt" into the device interface, and the camera simultaneously captures the user's smile.

[1178] 2. The device converts the input data and emotional state ("smile") into JSON format and sends an HTTP request to the server.

[1179] 3. The server receives this request and passes the condition "adult T-shirt" and the emotional state "smiling" to the generation AI and emotion engine.

[1180] 4. Generative AI generates images of T-shirts with simple and sophisticated designs, while the emotion engine suggests brighter colors and more cheerful designs.

[1181] 5. The server sends the adjusted image back to the device.

[1182] 6. The terminal displays the received image to the user, who confirms it.

[1183] Example 2: Image generation of Pokémon-style sneakers

[1184] 1. The user types "Pokémon-style sneakers" into the device interface, and the microphone simultaneously captures the user's excited voice.

[1185] 2. The device converts the input data and emotional state ("excitement") into JSON format and sends an HTTP request to the server.

[1186] 3. The server receives this request and passes the condition "Pokémon-style sneakers" and the emotional state "excited" to the generation AI and emotion engine.

[1187] 4. The generative AI generates images of sneakers based on Pokémon characters, and the emotion engine adjusts the designs to be more eye-catching and vibrant in color.

[1188] 5. The server sends the adjusted image back to the device.

[1189] 6. The terminal displays the received image to the user, who confirms it.

[1190] This system allows users to easily obtain fashion images that match their preferences, and also allows them to receive suggestions that suit their emotions at the time. The use of an emotion engine effectively solves the problems that arise in conventional search systems, improving the user experience.

[1191] The processing flow will be explained below.

[1192] Step 1:

[1193] The user opens the device's interface and inputs the desired fashion item, such as "adult T-shirt" or "Pokémon-style sneakers," into a text field. The device's camera and microphone also collect emotional data, such as the user's facial expressions and voice.

[1194] Step 2:

[1195] The user presses the "Send" button.

[1196] Step 3:

[1197] The device receives the user's input and emotion data and converts it into JSON format. For example, it generates the following JSON data:

[1198] json

[1199] {

[1200] "query": "adult t-shirt",

[1201] "emotion": "smile"

[1202] }

[1203] Step 4:

[1204] The device sets this JSON data as the body of an HTTP POST request and sends it to the server.

[1205] Step 5:

[1206] The server receives an HTTP POST request from the terminal.

[1207] Step 6:

[1208] The server parses the received JSON data and extracts the condition (in this case, "adult T-shirt") from the "query" field and the emotional state (in this case, "smiling") from the "emotion" field.

[1209] Step 7:

[1210] The conditions extracted by the server are input into the generation AI, and the emotional state is input into the emotion engine.

[1211] Step 8:

[1212] The server passes the conditions to the generation AI and requests it to generate a fashion image. At the same time, it passes the emotional state to the emotion engine and requests it to perform emotion-based analysis.

[1213] Step 9:

[1214] The generative AI generates fashion images based on the received conditions, and then references past data and learning models to create the optimal image.

[1215] Step 10:

[1216] The emotion engine adjusts the generated fashion image based on the user's emotional state, for example, adjusting the design to favor bright colors and a lively style if the emotional state is "smiling."

[1217] Step 11:

[1218] The server formats the generated fashion images and associated metadata (e.g., color, size, and material information) into JSON format.

[1219] Step 12:

[1220] The server sends the formatted response data to the terminal as an HTTP response.

[1221] Step 13:

[1222] The terminal receives an HTTP response from the server.

[1223] Step 14:

[1224] The terminal analyzes the response data, decodes the image data, and displays it on the screen.

[1225] Step 15:

[1226] The user can view the fashion images displayed on their device, and can save or share these images.

[1227] The above is a detailed description of each step from processing user input and emotion data to displaying fashion images.

[1228] Example 2

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

[1230] Conventional fashion image generation systems generate images based only on the user's desired conditions, and therefore do not provide suggestions that reflect the emotional state of each individual user. This makes it difficult to increase user satisfaction. Furthermore, the process of formatting the user's input data, sending it to the server, and analyzing it is inefficient, making it difficult to respond in real time. There is a need for a system that can propose appropriate fashion images based on the user's individual emotional state.

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

[1232] In this invention, the server includes means for generating individual fashion images based on conditions and emotional state input by a user and providing the generated images to the user, means for receiving the conditions and emotional state input by the user to a terminal, means for the terminal to format the conditions and emotional state into an appropriate data format and transmit the data to the server, means for the server to analyze the received data and extract the conditions and emotional state, means for generating fashion images using a generative AI model based on the conditions and adjusting the fashion images generated by an emotion engine based on the emotional state, means for returning the generated and adjusted fashion images to the terminal, and means for the terminal to display the generated and adjusted fashion images to the user. This enables more personalized fashion images to be proposed according to the user's emotional state, thereby increasing user satisfaction.

[1233] A "user" is an individual who wants to embody the image of a fashion item.

[1234] A "terminal" is an electronic device used by a user, such as a smartphone, PC, or tablet.

[1235] "Conditions" are information that indicates specific requirements or features of the fashion item desired by the user.

[1236] "Emotional state" is information that indicates the user's psychological and emotional state at any given time.

[1237] The "receiving means" includes mechanisms and functions for acquiring the conditions and emotional states input by the user to the terminal.

[1238] The "formatting means" has the function of converting the conditions and emotional state input by the user into an appropriate data format.

[1239] The "transmission means" includes a mechanism and a protocol for transmitting the data converted by the formatting means to the server.

[1240] The "analysis means" has the function of analyzing the data received by the server and extracting the condition and emotional state.

[1241] A "generative AI model" is an artificial intelligence model used to generate fashion images based on input conditions.

[1242] An "emotional engine" includes mechanisms and algorithms for adjusting the generated fashion image based on the user's emotional state.

[1243] The "returning means" includes mechanisms and protocols for returning the generated and adjusted fashion images to the terminal.

[1244] The "display means" has a mechanism and function for visually presenting the received fashion image to the user.

[1245] The present invention relates to a system that generates and provides individual fashion images to users based on conditions and emotional states input by the user. The system is composed of components including a user, a terminal, a server, and an emotion engine.

[1246] System Configuration

[1247] User

[1248] A user is an individual who wants to embody the image of a fashion item, and is a user of the system.

[1249] Terminal

[1250] The device is an electronic device used by the user, such as a smartphone, PC, tablet, etc. The user inputs conditions through the device, and the emotional state is acquired using sensors such as a camera and microphone.

[1251] server

[1252] The server is a computer system that contains the generative AI model and emotion engine and processes user requests. The server receives user input data, analyzes it, and performs the necessary processing.

[1253] Emotion Engine

[1254] The emotion engine is a software component for analyzing the user's emotional state and adjusting the generated fashion image based on that information.

[1255] Program Processing Details

[1256] User Input

[1257] The user opens the device's interface and inputs the desired fashion item, such as an "adult T-shirt" or "Pokémon-style sneakers." As the user inputs the information, the device's camera, microphone, and other sensors capture the user's emotional state (e.g., smile, surprise, sadness, etc.). These conditions and the emotional state are then recorded.

[1258] Input data formatting and transmission

[1259] The device analyzes the user's input data and emotional state, converts it into an appropriate data format (e.g., JSON), and then sends this data to the server as an HTTP POST request.

[1260] Data reception and analysis on the server

[1261] The server receives the HTTP POST request sent from the device and analyzes the input data and emotional state. The analyzed data is separated into conditions and emotional states, and is ready to be passed to the generative AI and emotion engine.

[1262] Image generation with generative AI and emotion engine

[1263] The server sends the user's input conditions (such as "adult T-shirt" or "Pokémon-style sneakers") to the generative AI model, and sends the user's emotional data (such as "smile" or "excitement") to the emotion engine. The generative AI generates fashion images that match the conditions, and the emotion engine adjusts the generated images appropriately based on the user's emotional state.

[1264] Returning and viewing images

[1265] The generated fashion image and related metadata (size, color, material information, etc.) are sent back from the server to the device as an HTTP response. The device analyzes the received image data and displays it in the user's interface. The user can then view the displayed image and save or share it as desired.

[1266] Specific use cases

[1267] Example 1: Generating images of adult T-shirts

[1268] 1. The user types "adult T-shirt" into the device interface, and the camera simultaneously captures the user's smile.

[1269] 2. The device converts the input data and emotional state ("smile") into JSON format and sends an HTTP request to the server.

[1270] 3. The server receives this request and passes the condition "adult T-shirt" and the emotional state "smiling" to the generative AI model and emotion engine.

[1271] 4. The generative AI model generates images of T-shirts with simple and sophisticated designs, while the emotion engine suggests brighter colors and more cheerful designs.

[1272] 5. The server sends the adjusted image back to the device.

[1273] 6. The terminal displays the received image to the user, who confirms it.

[1274] Example 2: Image generation of Pokémon-style sneakers

[1275] 1. The user types "Pokémon-style sneakers" into the device interface, and the microphone simultaneously captures the user's excited voice.

[1276] 2. The device converts the input data and emotional state ("excitement") into JSON format and sends an HTTP request to the server.

[1277] 3. The server receives this request and passes the condition "Pokémon-style sneakers" and the emotional state "excited" to the generative AI model and emotion engine.

[1278] 4. The generative AI model generates images of sneakers featuring Pokémon characters, and the emotion engine adjusts for more eye-catching designs and vibrant colors.

[1279] 5. The server sends the adjusted image back to the device.

[1280] 6. The terminal displays the received image to the user, who confirms it.

[1281] Prompt Sentence Examples

[1282] For adult t-shirt production:

[1283] "Generate simple yet sophisticated t-shirt designs for adults. Users smile."

[1284] To create Pokémon-style sneakers:

[1285] "Generate sneakers with eye-catching designs and vibrant colors featuring Pokémon characters. Users are super excited."

[1286] This system allows users to easily obtain fashion images that match their preferences and emotions, and enjoy a more personalized experience. The use of an emotion engine solves the issues that existed in conventional search systems, dramatically improving the user experience.

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

[1288] Step 1:

[1289] The user opens the interface using a device and inputs the conditions for the desired fashion item. Specifically, they enter "adult T-shirt" or "Pokémon-style sneakers" into the device's input field. At the same time, the device's camera and microphone are used to detect the user's emotional state (e.g., smiling, excited). The conditions and emotional state are obtained as input data.

[1290] Step 2:

[1291] The device receives and analyzes the user's input data (conditions and emotional state). Specifically, it analyzes sensor data from the camera and microphone to obtain emotional states such as smiles and excitement. It then converts this data into JSON format. The input is the user's condition and emotional state data, and the output is the data converted into JSON format.

[1292] Step 3:

[1293] The terminal sends the converted data to the server as an HTTP POST request. At this time, the endpoint URL of the server to which the data is to be sent is used. The input is the data converted to JSON format, and the output is the HTTP request sent to the server.

[1294] Step 4:

[1295] The server receives an HTTP POST request sent from the device. The received data is analyzed to separate the conditions and emotional state entered by the user. The input is the HTTP request data, and the output is the analyzed conditions and emotional state.

[1296] Step 5:

[1297] Based on the analyzed data, the server sends conditions to the generative AI model and emotional states to the emotion engine. The generative AI model generates an initial fashion image based on the conditions, and the emotion engine adjusts this image based on the emotional state. The input is the conditions and emotional state, and the output is the generated and adjusted fashion image.

[1298] Step 6:

[1299] The server returns the generated and adjusted fashion images and related metadata (size, color, material information, etc.) to the device as an HTTP response. The input is the generated and adjusted image data, and the output is the HTTP response to the device.

[1300] Step 7:

[1301] The device analyzes the fashion image data received from the server and displays it on the user's interface, allowing the user to check the generated image and save or share it. The input is the image data received as an HTTP response, and the output is the display to the user.

[1302] (Application example 2)

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

[1304] In the modern fashion industry, users have to make a lot of effort to narrow down their choices from a wide variety of items. Furthermore, conventional fashion image generation systems lack personalized suggestions based on the user's emotions, making it difficult to find outfits that fit the user's actual needs and mood. In particular, in virtual stores, it is necessary to provide more appropriate fashion suggestions based on emotions when users virtually try on clothes.

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

[1306] In this invention, the server includes means for receiving conditions input to the terminal by the user, means for generating fashion images using a generation AI based on the conditions, means for returning the generated fashion images to the terminal, means for detecting the user's emotions using an emotion recognition engine, means for adjusting the output of the generation AI based on the detected emotions, and means for displaying the adjusted fashion images on the terminal. This allows users to easily obtain fashion images that suit their emotions and moods, and to find the optimal coordination that fits their emotions in a virtual store.

[1307] A "user" refers to an individual who wishes to embody a fashion image.

[1308] "Terminal" refers to electronic devices used by users, such as smartphones, personal computers, and tablets.

[1309] "Conditions" refer to the desires and requests regarding fashion items that a user inputs into the terminal.

[1310] "Generative AI" refers to artificial intelligence that generates new fashion images based on conditions entered by the user.

[1311] "Fashion image" refers to the visual of a specific fashion item generated by generative AI.

[1312] An "emotion recognition engine" is an engine that detects and analyzes user emotions and provides data to adjust the output of generative AI.

[1313] "Server" refers to the central computer system that receives and processes user input data and emotion data.

[1314] "Means for receiving" refers to the function by which the server receives the conditions and emotion data sent from the terminal.

[1315] "Means for generation" refers to the function by which the generative AI creates fashion images based on the received conditions.

[1316] "Means for sending back" refers to the function of sending back the generated fashion image from the server to the terminal.

[1317] "Means for detecting" refers to a function for recognizing a user's emotions and analyzing their emotional state.

[1318] "Adjustment means" refers to a function for optimizing the output of the generative AI based on the emotions detected by the emotion recognition engine.

[1319] "Display means" refers to a function that visually presents the fashion images received by the terminal from the server to the user.

[1320] This invention is a system that generates individual fashion images based on user-entered conditions, recognizes the user's emotions, and provides optimal fashion images based on those emotions. This system consists of a user, a terminal, a server, an emotion recognition engine, and a generation AI model.

[1321] System configuration

[1322] The system includes the following major components:

[1323] 1. User: An individual who wants to embody the image of a fashion item.

[1324] 2. Device: Electronic devices used by users, such as smartphones, computers, and tablets.

[1325] 3. Server: A computer system that includes a generation AI and receives user requests and performs image generation.

[1326] 4. Emotion recognition engine: Recognizes the user's emotions along with the user's input conditions and performs analysis based on those emotions.

[1327] System Operation Overview

[1328] Users input their desired fashion item preferences through their device, and this information, along with the user's emotional state, is sent to the server. The server then uses a generative AI and emotion recognition engine to generate fashion images based on the received preferences and emotional state, and sends the results back to the device. This allows users to receive specific visuals of their desired fashion items and suggestions that fit their emotions.

[1329] Detailed explanation of program processing

[1330] First, the user inputs the desired fashion items into the device interface. At the same time, the user's emotional state is also captured through sensors such as the device's camera and microphone. This information is converted into an appropriate format and sent to the server as an HTTP request.

[1331] The server receives this request and analyzes the input data and emotional data. Conditions and emotional states are extracted from the analyzed data and passed to the generation AI and emotion recognition engine. The generation AI generates fashion images that fit the conditions, and the emotion recognition engine adjusts them based on the emotional state. The generated fashion images are then sent back to the device from the server along with related metadata.

[1332] Hardware and software used

[1333] The system uses the following hardware and software:

[1334] Smartphones, computers, tablets, etc.: the devices through which users interact with the interface.

[1335] Emotion recognition engine: An engine for analyzing user emotions.

[1336] Generative AI model: An artificial intelligence model for generating fashion images.

[1337] HTTP request processing library: A software tool for sending and receiving data.

[1338] Specific examples

[1339] For example, if a user inputs "rock-style jacket" into the device interface and the camera captures an excited expression, the server receives the criteria "rock-style jacket" and the emotional state of "excited." The generative AI generates a rock-style jacket, and the emotion recognition engine suggests more flashy designs and dynamic colors. The final image is sent back to the user for review.

[1340] Example prompt sentence:

[1341] "Fashion item: Rock style jacket, Emotion: Excitement"

[1342] This allows users to receive personalized fashion suggestions based on their emotions.

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

[1344] Step 1:

[1345] The user opens the device interface and inputs the desired fashion item. For example, they might type "rock style jacket" into a text box. The device's camera and microphone also capture the user's emotional state (e.g., smile, surprise, excitement). The input data and emotional data are collected and stored on the device.

[1346] Input: A condition about a fashion item ("rock-style jacket") and the user's emotional state ("excitement")

[1347] Output: Input data and emotion data collected and saved on the device

[1348] Step 2:

[1349] The device converts the collected user input data and emotion data into an appropriate format (e.g., JSON format) and sends it to the server as an HTTP POST request. This data includes the user's desired fashion item conditions and emotional state.

[1350] Input: Input data and emotion data stored on the device

[1351] Output: HTTP POST request sent to the server

[1352] Step 3:

[1353] The server receives the HTTP POST request sent from the device, analyzes the data, extracts conditions and emotional states from the received data, and prepares the data for passing to the generative AI model and emotion recognition engine.

[1354] Input: HTTP POST request sent from the terminal

[1355] Output: Input data to the generative AI model and emotion recognition engine

[1356] Step 4:

[1357] The generative AI model generates fashion images based on the condition data it receives. Furthermore, the emotion recognition engine adjusts the output of the generative AI model based on the emotional state data it receives. For example, if the emotion is "excited," it adjusts the design and color to be more flashy and dynamic.

[1358] Input: Condition data for generative AI models, and emotional state data for emotion recognition engines

[1359] Output: Adjusted fashion image

[1360] Step 5:

[1361] The server returns the adjusted fashion image obtained from the generative AI model and emotion recognition engine, along with related metadata (e.g., size, color, and material information), to the device as an HTTP response.

[1362] Input: Adjusted fashion images and associated metadata

[1363] Output: HTTP response to the device

[1364] Step 6:

[1365] The device analyzes the HTTP response received from the server and displays the fashion image to the user, who can then check the displayed image and save or share it as needed.

[1366] Input: HTTP response received from the server

[1367] Output: Fashion images displayed to the user

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

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

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

[1371] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1385] This invention relates to a system that uses generative AI to generate fashion images based on conditions entered by a user. This system is composed of elements including a user, a terminal, and a server, and is described in detail below.

[1386] System configuration

[1387] The system includes the following major components:

[1388] 1. User: An individual who wants to embody the image of a fashion item.

[1389] 2. Device: Electronic devices used by users, such as smartphones, computers, and tablets.

[1390] 3. Server: A computer system that includes a generation AI and receives user requests and performs image generation.

[1391] Program Processing Overview

[1392] Users input the specifications for the fashion items they are looking for through their device, and this information is sent to the server. The server uses generative AI to generate fashion images based on the received specifications and sends the results back to the device. This allows users to obtain specific visuals of the fashion items they desire.

[1393] Program Processing Details

[1394] User Input

[1395] Users open a dedicated interface on their device and enter the desired fashion items, such as "adult T-shirts" or "Pokémon-style sneakers." Once the input is complete, the data is sent by clicking the "Send" button.

[1396] Input data formatting and transmission

[1397] The device parses the user's input data, converts it into an appropriate format (e.g., JSON), and sends it to the server as an HTTP POST request.

[1398] Data reception and analysis on the server

[1399] The server receives the request sent from the device and analyzes the input data. Conditions are extracted from the analyzed data and prepared for passing to the generation AI.

[1400] Image generation by generative AI

[1401] The server passes the analysis results to the generation AI as input data. Based on this, the generation AI generates fashion images that match the conditions. The generation AI uses past data and learning models to create the optimal image.

[1402] Returning images

[1403] The generated fashion image and associated metadata (e.g., size, color, and material information) are sent back to the terminal as an HTTP response from the server.

[1404] Displaying an image to the user

[1405] The device analyzes the image data received from the server and displays it to the user, who can then view the image and save or share it as needed.

[1406] Specific use cases

[1407] Example 1: Generating images of adult T-shirts

[1408] 1. The user enters "adult T-shirt" into the device interface and presses the "Send" button.

[1409] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[1410] 3. The server receives this request and passes the condition "adult T-shirt" to the generation AI.

[1411] 4. The generative AI generates an image of a T-shirt with a simple yet sophisticated design and sends it back to the server.

[1412] 5. The server sends the generated image back to the device.

[1413] 6. The terminal displays the received image to the user, who confirms it.

[1414] Example 2: Image generation of Pokémon-style sneakers

[1415] 1. The user types "Pokémon-style sneakers" into the device interface and presses the "Send" button.

[1416] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[1417] 3. The server receives this request and passes the condition "Pokémon-style sneakers" to the generation AI.

[1418] 4. The generation AI generates an image of a sneaker featuring a Pokémon character and sends it back to the server.

[1419] 5. The server sends the generated image back to the device.

[1420] 6. The terminal displays the received image to the user, who confirms it.

[1421] This system allows users to easily obtain fashion images that suit their preferences, effectively resolving the problems that have arisen with conventional search systems.

[1422] The processing flow will be explained below.

[1423] Step 1:

[1424] The user opens the device interface and inputs the desired fashion item, such as "adult T-shirt" or "Pokémon-style sneakers," into a text field.

[1425] Step 2:

[1426] The user presses the "Send" button.

[1427] Step 3:

[1428] The terminal takes the user's input and converts it to JSON format, for example generating the following JSON data:

[1429] json

[1430] {

[1431] "query": "adult t-shirts"

[1432] }

[1433] Step 4:

[1434] The device sets this JSON data as the body of an HTTP POST request and sends it to the server.

[1435] Step 5:

[1436] The server receives an HTTP POST request from the terminal.

[1437] Step 6:

[1438] The server parses the received JSON data and extracts the condition (in this case, "adult T-shirts") from the "query" field.

[1439] Step 7:

[1440] The conditions extracted by the server are set as input data for the generation AI.

[1441] Step 8:

[1442] The server passes the conditions to the generation AI and requests it to generate a fashion image.

[1443] Step 9:

[1444] The generative AI generates fashion images based on the received conditions, where it references its internal model and past data to create the optimal image.

[1445] Step 10:

[1446] The generated AI sends the generated fashion image back to the server.

[1447] Step 11:

[1448] The server formats the received fashion images and associated metadata (e.g., color, size, and material information) into JSON format.

[1449] Step 12:

[1450] The server sends the formatted response data to the terminal as an HTTP response.

[1451] Step 13:

[1452] The terminal receives an HTTP response from the server.

[1453] Step 14:

[1454] The terminal analyzes the response data, decodes the image data, and displays it on the screen.

[1455] Step 15:

[1456] The user can view the fashion images displayed on their device, and can save or share these images.

[1457] The above is a detailed description of each step from user input to display of a fashion image.

[1458] Example 1

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

[1460] Conventional search systems have the problem that it is difficult for users to see specific visuals of the fashion items they want, and the sheer volume of search results means it takes a long time for users to find the information they are looking for. Even if users input their desired criteria, there are limited ways to obtain specific images based on those criteria. To solve these problems, a system is needed that allows users to easily obtain the fashion images they desire.

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

[1462] In this invention, the server includes means for the terminal to analyze user input data and convert it into an appropriate format, means for transmitting the formatted data to the server, means for the server to receive the formatted data, means for the server to analyze the received data and extract conditions, means for generating fashion images using a generative AI model based on the conditions, means for returning the generated fashion images to the terminal, and means for the terminal to analyze the image data received and display it to the user. This makes it possible for the user to easily and quickly obtain specific fashion images based on the conditions desired.

[1463] "User input" refers to the act of an individual using the system inputting the conditions relating to the fashion item they desire into the terminal interface.

[1464] A "terminal" is an electronic device used by a user, such as a smartphone, PC, or tablet, and is a device that receives user input and communicates with a server.

[1465] The "server" is a computer system that includes a generative AI model, receives and analyzes user input data, generates fashion images based on the conditions, and returns them to the terminal.

[1466] A "generative AI model" is an artificial intelligence algorithm that uses past data and learning models to generate fashion images that match received conditions.

[1467] A "prompt" is an instruction sentence input into a generative AI model, which includes the conditions for generating a specific fashion image.

[1468] An "HTTP POST request" is one of the communication protocols used by a terminal to send data to a server, and includes formatted input data as a request body.

[1469] "Formatting" is the process of converting the data entered by the user into a form that is easy to handle within the system (for example, JSON format).

[1470] "Data analysis" is the process of examining the data received by the server in detail, extracting conditions, and preparing it in the format required for subsequent processing.

[1471] A "user interface" is a screen or input form that allows a user to operate a system, and is used when making user input.

[1472] "Image generation" is the process by which a generative AI model creates a fashion image based on user input.

[1473] "Metadata" is additional information associated with the generated fashion image, including, for example, size, color, material, etc.

[1474] This invention relates to a system that uses a generative AI model to generate fashion images based on user-entered conditions. This system is composed of the following elements: a user, a terminal, and a server.

[1475] System configuration

[1476] The system includes the following main components:

[1477] 1. User: An individual who wants to embody the image of a fashion item.

[1478] 2. Terminal: An electronic device used by a user, such as a smartphone, PC, or tablet. It is a device that receives user input and communicates with a server.

[1479] 3. Server: A computer system that contains the generative AI model, receives user requests, and performs image generation.

[1480] Program Processing Overview

[1481] Users input the specifications for the fashion items they are looking for through their device, and this information is sent to the server. The server uses a generative AI model to generate fashion images based on the received specifications and sends the results back to the device. This allows users to obtain specific visuals of the fashion items they desire.

[1482] Hardware and software usage

[1483] In this system, devices such as smartphones, PCs, and tablets are used, and the server is a computer system with high-performance computing capabilities. The generative AI model uses software frameworks with deep learning algorithms (e.g., TensorFlow, PyTorch, etc.). Communication between the device and server is via the HTTP protocol, with data being sent and received in JSON format.

[1484] Specific use cases

[1485] Example 1: Generating images of adult T-shirts

[1486] 1. The user enters "adult T-shirt" into the device interface and presses the "Send" button.

[1487] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[1488] 3. The server receives this request and passes the condition "adult T-shirt" to the generative AI model.

[1489] 4. The generative AI model generates an image of a T-shirt with a simple yet sophisticated design and sends it back to the server.

[1490] 5. The server sends the generated image back to the device.

[1491] 6. The terminal displays the received image to the user, who confirms it.

[1492] Example prompt:

[1493] "Create simple yet sophisticated adult T-shirt designs."

[1494] Example 2: Image generation of Pokémon-style sneakers

[1495] 1. The user types "Pokémon-style sneakers" into the device interface and presses the "Send" button.

[1496] 2. The device converts this input data into JSON format and sends an HTTP request to the server.

[1497] 3. The server receives this request and passes the condition "Pokémon-style sneakers" to the generative AI model.

[1498] 4. The generative AI model generates images of sneakers featuring Pokémon characters and sends them back to the server.

[1499] 5. The server sends the generated image back to the device.

[1500] 6. The terminal displays the received image to the user, who confirms it.

[1501] Example prompt:

[1502] "Generate unique sneaker designs featuring Pokémon characters."

[1503] This system allows users to easily obtain fashion images that match their preferences, effectively resolving the problems that have arisen with conventional search systems. Specifically, it provides a means to resolve the problem of the large number of search results, which make it take a long time to find the desired information, and the problem of not being able to obtain a specific visual image.

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

[1505] Step 1: User input

[1506] The user uses the device interface (smartphone app or web browser) to input the desired fashion item. Specifically, the user enters a condition such as "adult T-shirt" into a text box on the screen and clicks the "Submit" button. This input data triggers the next processing step.

[1507] Input: Conditions for the desired fashion item (e.g., "Adult T-shirt")

[1508] Output: User condition input data (e.g. "Adult T-shirt")

[1509] Step 2: Convert input data format

[1510] The terminal analyzes the condition data entered by the user and converts it into a format that is easy to handle within the system. In this case, the data is converted into JSON format.

[1511] Input: User condition input data (e.g. "Adult T-shirt")

[1512] Data Calculation: Convert condition data to JSON format (e.g., {"item": "Adult T-shirt"})

[1513] Output: Formatted JSON data (e.g., {"item": "Adult T-shirt"})

[1514] Specific operation: The format conversion function on the terminal is executed.

[1515] Step 3: Sending formatted data

[1516] The terminal sends the formatted data to the server as an HTTP POST request.

[1517] Input: Formatted JSON data (e.g., {"item": "Adult T-shirt"})

[1518] Data calculation: Send data in the body of the HTTP request

[1519] Output: HTTP request sent

[1520] Specific operation: The device sends an HTTP POST request to the specified endpoint on the server.

[1521] Step 4: Receiving data on the server

[1522] The server receives the HTTP POST request sent from the terminal and extracts data from the received request body.

[1523] Input: HTTP request (including formatted JSON data)

[1524] Data operation: Extract data from the request body (e.g., {"item": "Adult T-shirt"})

[1525] Output: Extracted JSON data

[1526] Specific behavior: The receiving endpoint on the server detects the request and executes the data extraction function.

[1527] Step 5: Data analysis and condition extraction

[1528] The server analyzes the received data and extracts the conditions entered by the user. During the analysis stage, it also checks the consistency of the data.

[1529] Input: Extracted JSON data (e.g., {"item": "Adult T-shirt"})

[1530] Data calculation: Analysis and extraction of conditional data (e.g., item name "Adult T-shirt")

[1531] Output: Extracted condition data (e.g. "Adult T-shirts")

[1532] Specific operation: The server's data analysis module analyzes the data and extracts conditions.

[1533] Step 6: Image generation using generative AI

[1534] The server inputs the extracted condition data into the generative AI model and issues instructions for generating fashion images. The generative AI model uses past data and learning models to generate fashion images that match the requested conditions.

[1535] Input: Condition data (e.g. "Adult T-shirts")

[1536] Data calculation: Input as a prompt to the generative AI model (e.g., "A simple and sophisticated T-shirt for adults")

[1537] Output: Generated fashion images

[1538] Specific operation: The server passes the prompt sentence to the generative AI model, and the image generation function is executed.

[1539] Step 7: Sending the image from the server back to the device

[1540] The fashion image generated by the generative AI and its associated metadata are sent back to the device from the server as an HTTP response.

[1541] Input: Generated fashion images and metadata

[1542] Data operations: Reconstruct data into a response format (e.g., {"image": "base64-encoded-image", "size": "L", "color": "blue", "material": "cotton"})

[1543] Output: HTTP response

[1544] Specific operation: The server constructs response data and sends it to the terminal as an HTTP response.

[1545] Step 8: Displaying the image to the user

[1546] The device receives the HTTP response from the server, analyzes the image data, and displays it to the user, who can then check the final image of the fashion item.

[1547] Input: HTTP response (including image data and metadata)

[1548] Data calculation: Analysis of response data

[1549] Output: The image displayed in the user interface

[1550] Specific operation: The device analyzes the response and displays the image data on the screen.

[1551] (Application example 1)

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

[1553] To provide a system for generating fashion images based on conditions input by a user, with a means for enabling a user to try on and check the generated fashion images, thereby enabling the user to easily obtain specific visual feedback that cannot be obtained by a normal search system.

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

[1555] In this invention, the server includes means for generating individual fashion images based on conditions input by the user and means for allowing the user to virtually try on the generated fashion images, thereby enabling the user to apply the fashion images generated based on the conditions input to their own photos or avatars and check specific styling.

[1556] A "user" is an individual who wants to embody the image of a fashion item.

[1557] A "terminal" is an electronic device used by a user, such as a smartphone, PC, or tablet.

[1558] A "server" is a computer system that includes a generation AI and receives user requests and generates images.

[1559] "Generative AI" is an artificial intelligence model that generates fashion images based on conditions entered by the user.

[1560] "Conditions" refer to detailed information and desired characteristics about a fashion item that a user inputs into a terminal.

[1561] "Fashion images" are visual representations of fashion items created by generative AI.

[1562] "Virtual try-on" refers to a user applying a generated fashion image to their own photo or avatar, allowing them to check the look as if they were trying it on.

[1563] The system for implementing this invention is composed of a user, a terminal, and a server. Specifically, the user inputs fashion parameters using a terminal such as a smartphone, and a generation AI generates fashion images based on the parameters. Finally, the system provides a means for the user to virtually try on the images.

[1564] System Program Overview

[1565] First, the user uses the device to input fashion criteria based on their preferences. For example, a condition could be "casual autumn outfit coordination." This input data is converted into an appropriate format (e.g., JSON format) by the device and sent to the server as an HTTP request.

[1566] The server receives requests using a web framework called Flask. The received data is analyzed and condition data is extracted. This condition data is passed to an AI model library (tentative name: some_ai_module). This AI model uses past data and learning models to generate fashion images based on the user's requests.

[1567] The generated fashion image is sent back from the server to the device. The device displays the received fashion image to the user. At this time, the user can virtually try on the generated fashion image. Virtual try-on refers to overlaying the fashion image on the user's photo or avatar, allowing the user to check how the item will look when actually worn.

[1568] Hardware and software used

[1569] Hardware: General cloud servers, smartphones, tablets, etc.

[1570] Software: Flask (web framework), some_ai_module (AI model library)

[1571] Specific examples

[1572] As a specific example, if a user wants to coordinate casual autumn clothing, the user can follow the following steps.

[1573] 1. The user opens the smartphone application interface and enters "Casual Fall Outfit Coordination."

[1574] 2. By pressing the "Send" button, the device converts the input data into JSON format and sends an HTTP POST request to the server.

[1575] 3. The server receives the request and parses and extracts the condition data.

[1576] 4. Use some_ai_module to generate fashion images based on conditions.

[1577] 5. The generated image is sent back from the server to the device.

[1578] 6. The user checks the generated image on the device and tries on the clothes virtually.

[1579] Prompt Sentence Examples

[1580] The user inputs "Casual autumn outfit coordination" as a prompt sentence. Then, the user presses the send button to send the data to the server.

[1581] This allows users to easily create their desired fashion image and check the visual feedback through virtual try-on, making it easier for users to select and purchase more specific fashion items.

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

[1583] Step 1:

[1584] The user inputs fashion criteria using the terminal. For example, the user inputs a criteria such as "casual autumn outfit coordination" into a text field.

[1585] Step 2:

[1586] The user presses the "Submit" button to send the input data from the device to the server, which then converts the input data into an appropriate format (e.g., JSON) and sends it to the server as an HTTP POST request.

[1587] Step 3:

[1588] The server uses Flask to receive HTTP requests from users, which are then parsed in JSON format to extract conditional data.

[1589] Step 4:

[1590] The server prepares the analyzed condition data to be passed to the generation AI. Specifically, it converts the data into the required format so that it can be input to the generation AI.

[1591] Step 5:

[1592] The server inputs condition data into the generation AI (some_ai_module) and generates fashion images. The generation AI uses past data and learning models to generate the optimal fashion images that match the conditions.

[1593] Step 6:

[1594] After the generation AI generates the fashion image, the server receives the generated image data and prepares to send it back to the device in JSON format.

[1595] Step 7:

[1596] The server returns the generated fashion image data to the terminal as an HTTP response.

[1597] Step 8:

[1598] The device analyzes the received fashion image data and displays it to the user, who can then check the displayed image and save or share it as needed.

[1599] Step 9:

[1600] Users can virtually try on the generated fashion images. Specifically, the fashion images are superimposed on the user's photo or avatar, allowing them to see how they will look when actually worn.

[1601] In this way, the user can specifically check and try on the fashion image generated based on the conditions input by the user.

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

[1603] The present invention relates to a system that generates individual fashion images based on user-entered conditions, recognizes the user's emotions, and provides optimal fashion images based on those emotions. This system is composed of components: a user, a terminal, a server, and an emotion engine. The details are described below.

[1604] System configuration

[1605] The system includes the following major components:

[1606] 1. User: An individual who wants to embody the image of a fashion item.

[1607] 2. Device: Electronic devices used by users, such as smartphones, computers, and tablets.

[1608] 3. Server: A computer system that includes a generation AI and receives user requests and performs image generation.

[1609] 4. Emotion engine: Recognizes the user's emotions along with the user's input conditions and performs analysis based on those emotions.

[1610] Program Processing Overview

[1611] The user inputs the specifications for the fashion items through the device, and this information, along with the user's emotional state, is sent to the server. The server uses a generative AI and emotion engine to generate fashion images based on the received specifications and emotional state, and sends the results back to the device. This allows the user to receive specific visuals of the fashion items they desire and suggestions that fit their emotions.

[1612] Program Processing Details

[1613] User Input

[1614] The user opens the device's interface and inputs the desired fashion item, such as an "adult T-shirt" or "Pokémon-style sneakers." As the user inputs the information, the device's camera, microphone, and other sensors capture the user's emotional state (e.g., smile, surprise, sadness, etc.). The user's emotional state and the conditions are then recorded together.

[1615] Input data formatting and transmission

[1616] The device analyzes the user's input data and emotional state, converts it into an appropriate format (e.g., JSON), and sends it to the server as an HTTP POST request.

[1617] Data reception and analysis on the server

[1618] The server receives requests sent from the device and analyzes the input data and emotional state. Conditions and emotional states are extracted from the analyzed data and prepared for passing to the generative AI and emotion engine.

[1619] Image generation with generative AI and emotion engine

[1620] The server passes the conditions to the generation AI and the emotional state to the emotion engine. The emotion engine adjusts the output of the generation AI based on the emotional state. The generation AI generates fashion images that match the conditions and adjusts the optimal design, color, and style based on the emotion.

[1621] Returning images

[1622] The generated fashion image and associated metadata (e.g., size, color, and material information) are sent back from the server to the device as an HTTP response.

[1623] Displaying an image to the user

[1624] The device analyzes the image data received from the server and displays it to the user, who can then view the image and save or share it as needed.

[1625] Specific use cases

[1626] Example 1: Generating images of adult T-shirts

[1627] 1. The user types "adult T-shirt" into the device interface, and the camera simultaneously captures the user's smile.

[1628] 2. The device converts the input data and emotional state ("smile") into JSON format and sends an HTTP request to the server.

[1629] 3. The server receives this request and passes the condition "adult T-shirt" and the emotional state "smiling" to the generation AI and emotion engine.

[1630] 4. Generative AI generates images of T-shirts with simple and sophisticated designs, while the emotion engine suggests brighter colors and more cheerful designs.

[1631] 5. The server sends the adjusted image back to the device.

[1632] 6. The terminal displays the received image to the user, who confirms it.

[1633] Example 2: Image generation of Pokémon-style sneakers

[1634] 1. The user types "Pokémon-style sneakers" into the device interface, and the microphone simultaneously captures the user's excited voice.

[1635] 2. The device converts the input data and emotional state ("excitement") into JSON format and sends an HTTP request to the server.

[1636] 3. The server receives this request and passes the condition "Pokémon-style sneakers" and the emotional state "excited" to the generation AI and emotion engine.

[1637] 4. The generative AI generates images of sneakers based on Pokémon characters, and the emotion engine adjusts the designs to be more eye-catching and vibrant in color.

[1638] 5. The server sends the adjusted image back to the device.

[1639] 6. The terminal displays the received image to the user, who confirms it.

[1640] This system allows users to easily obtain fashion images that match their preferences, and also allows them to receive suggestions that suit their emotions at the time. The use of an emotion engine effectively solves the problems that arise in conventional search systems, improving the user experience.

[1641] The processing flow will be explained below.

[1642] Step 1:

[1643] The user opens the device's interface and inputs the desired fashion item, such as "adult T-shirt" or "Pokémon-style sneakers," into a text field. The device's camera and microphone also collect emotional data, such as the user's facial expressions and voice.

[1644] Step 2:

[1645] The user presses the "Send" button.

[1646] Step 3:

[1647] The device receives the user's input and emotion data and converts it into JSON format. For example, it generates the following JSON data:

[1648] json

[1649] {

[1650] "query": "adult t-shirt",

[1651] "emotion": "smile"

[1652] }

[1653] Step 4:

[1654] The device sets this JSON data as the body of an HTTP POST request and sends it to the server.

[1655] Step 5:

[1656] The server receives an HTTP POST request from the terminal.

[1657] Step 6:

[1658] The server parses the received JSON data and extracts the condition (in this case, "adult T-shirt") from the "query" field and the emotional state (in this case, "smiling") from the "emotion" field.

[1659] Step 7:

[1660] The conditions extracted by the server are input into the generation AI, and the emotional state is input into the emotion engine.

[1661] Step 8:

[1662] The server passes the conditions to the generation AI and requests it to generate a fashion image. At the same time, it passes the emotional state to the emotion engine and requests it to perform emotion-based analysis.

[1663] Step 9:

[1664] The generative AI generates fashion images based on the received conditions, and then references past data and learning models to create the optimal image.

[1665] Step 10:

[1666] The emotion engine adjusts the generated fashion image based on the user's emotional state, for example, adjusting the design to favor bright colors and a lively style if the emotional state is "smiling."

[1667] Step 11:

[1668] The server formats the generated fashion images and associated metadata (e.g., color, size, and material information) into JSON format.

[1669] Step 12:

[1670] The server sends the formatted response data to the terminal as an HTTP response.

[1671] Step 13:

[1672] The terminal receives an HTTP response from the server.

[1673] Step 14:

[1674] The terminal analyzes the response data, decodes the image data, and displays it on the screen.

[1675] Step 15:

[1676] The user can view the fashion images displayed on their device, and can save or share these images.

[1677] The above is a detailed description of each step from processing user input and emotion data to displaying fashion images.

[1678] Example 2

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

[1680] Conventional fashion image generation systems generate images based only on the user's desired conditions, and therefore do not provide suggestions that reflect the emotional state of each individual user. This makes it difficult to increase user satisfaction. Furthermore, the process of formatting the user's input data, sending it to the server, and analyzing it is inefficient, making it difficult to respond in real time. There is a need for a system that can propose appropriate fashion images based on the user's individual emotional state.

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

[1682] In this invention, the server includes means for generating individual fashion images based on conditions and emotional state input by a user and providing the generated images to the user, means for receiving the conditions and emotional state input by the user to a terminal, means for the terminal to format the conditions and emotional state into an appropriate data format and transmit the data to the server, means for the server to analyze the received data and extract the conditions and emotional state, means for generating fashion images using a generative AI model based on the conditions and adjusting the fashion images generated by an emotion engine based on the emotional state, means for returning the generated and adjusted fashion images to the terminal, and means for the terminal to display the generated and adjusted fashion images to the user. This enables more personalized fashion images to be proposed according to the user's emotional state, thereby increasing user satisfaction.

[1683] A "user" is an individual who wants to embody the image of a fashion item.

[1684] A "terminal" is an electronic device used by a user, such as a smartphone, PC, or tablet.

[1685] "Conditions" are information that indicates specific requirements or features of the fashion item desired by the user.

[1686] "Emotional state" is information that indicates the user's psychological and emotional state at any given time.

[1687] The "receiving means" includes mechanisms and functions for acquiring the conditions and emotional states input by the user to the terminal.

[1688] The "formatting means" has the function of converting the conditions and emotional state input by the user into an appropriate data format.

[1689] The "transmission means" includes a mechanism and a protocol for transmitting the data converted by the formatting means to the server.

[1690] The "analysis means" has the function of analyzing the data received by the server and extracting the condition and emotional state.

[1691] A "generative AI model" is an artificial intelligence model used to generate fashion images based on input conditions.

[1692] An "emotional engine" includes mechanisms and algorithms for adjusting the generated fashion image based on the user's emotional state.

[1693] The "returning means" includes mechanisms and protocols for returning the generated and adjusted fashion images to the terminal.

[1694] The "display means" has a mechanism and function for visually presenting the received fashion image to the user.

[1695] The present invention relates to a system that generates and provides individual fashion images to users based on conditions and emotional states input by the user. The system is composed of components including a user, a terminal, a server, and an emotion engine.

[1696] System Configuration

[1697] User

[1698] A user is an individual who wants to embody the image of a fashion item, and is a user of the system.

[1699] Terminal

[1700] The device is an electronic device used by the user, such as a smartphone, PC, tablet, etc. The user inputs conditions through the device, and the emotional state is acquired using sensors such as a camera and microphone.

[1701] server

[1702] The server is a computer system that contains the generative AI model and emotion engine and processes user requests. The server receives user input data, analyzes it, and performs the necessary processing.

[1703] Emotion Engine

[1704] The emotion engine is a software component for analyzing the user's emotional state and adjusting the generated fashion image based on that information.

[1705] Program Processing Details

[1706] User Input

[1707] The user opens the device's interface and inputs the desired fashion item, such as an "adult T-shirt" or "Pokémon-style sneakers." As the user inputs the information, the device's camera, microphone, and other sensors capture the user's emotional state (e.g., smile, surprise, sadness, etc.). These conditions and the emotional state are then recorded.

[1708] Input data formatting and transmission

[1709] The device analyzes the user's input data and emotional state, converts it into an appropriate data format (e.g., JSON), and then sends this data to the server as an HTTP POST request.

[1710] Data reception and analysis on the server

[1711] The server receives the HTTP POST request sent from the device and analyzes the input data and emotional state. The analyzed data is separated into conditions and emotional states, and is ready to be passed to the generative AI and emotion engine.

[1712] Image generation with generative AI and emotion engine

[1713] The server sends the user's input conditions (such as "adult T-shirt" or "Pokémon-style sneakers") to the generative AI model, and sends the user's emotional data (such as "smile" or "excitement") to the emotion engine. The generative AI generates fashion images that match the conditions, and the emotion engine adjusts the generated images appropriately based on the user's emotional state.

[1714] Returning and viewing images

[1715] The generated fashion image and related metadata (size, color, material information, etc.) are sent back from the server to the device as an HTTP response. The device analyzes the received image data and displays it in the user's interface. The user can then view the displayed image and save or share it as desired.

[1716] Specific use cases

[1717] Example 1: Generating images of adult T-shirts

[1718] 1. The user types "adult T-shirt" into the device interface, and the camera simultaneously captures the user's smile.

[1719] 2. The device converts the input data and emotional state ("smile") into JSON format and sends an HTTP request to the server.

[1720] 3. The server receives this request and passes the condition "adult T-shirt" and the emotional state "smiling" to the generative AI model and emotion engine.

[1721] 4. The generative AI model generates images of T-shirts with simple and sophisticated designs, while the emotion engine suggests brighter colors and more cheerful designs.

[1722] 5. The server sends the adjusted image back to the device.

[1723] 6. The terminal displays the received image to the user, who confirms it.

[1724] Example 2: Image generation of Pokémon-style sneakers

[1725] 1. The user types "Pokémon-style sneakers" into the device interface, and the microphone simultaneously captures the user's excited voice.

[1726] 2. The device converts the input data and emotional state ("excitement") into JSON format and sends an HTTP request to the server.

[1727] 3. The server receives this request and passes the condition "Pokémon-style sneakers" and the emotional state "excited" to the generative AI model and emotion engine.

[1728] 4. The generative AI model generates images of sneakers featuring Pokémon characters, and the emotion engine adjusts for more eye-catching designs and vibrant colors.

[1729] 5. The server sends the adjusted image back to the device.

[1730] 6. The terminal displays the received image to the user, who confirms it.

[1731] Prompt Sentence Examples

[1732] For adult t-shirt production:

[1733] "Generate simple yet sophisticated t-shirt designs for adults. Users smile."

[1734] To create Pokémon-style sneakers:

[1735] "Generate sneakers with eye-catching designs and vibrant colors featuring Pokémon characters. Users are super excited."

[1736] This system allows users to easily obtain fashion images that match their preferences and emotions, and enjoy a more personalized experience. The use of an emotion engine solves the issues that existed in conventional search systems, dramatically improving the user experience.

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

[1738] Step 1:

[1739] The user opens the interface using a device and inputs the conditions for the desired fashion item. Specifically, they enter "adult T-shirt" or "Pokémon-style sneakers" into the device's input field. At the same time, the device's camera and microphone are used to detect the user's emotional state (e.g., smiling, excited). The conditions and emotional state are obtained as input data.

[1740] Step 2:

[1741] The device receives and analyzes the user's input data (conditions and emotional state). Specifically, it analyzes sensor data from the camera and microphone to obtain emotional states such as smiles and excitement. It then converts this data into JSON format. The input is the user's condition and emotional state data, and the output is the data converted into JSON format.

[1742] Step 3:

[1743] The terminal sends the converted data to the server as an HTTP POST request. At this time, the endpoint URL of the server to which the data is to be sent is used. The input is the data converted to JSON format, and the output is the HTTP request sent to the server.

[1744] Step 4:

[1745] The server receives an HTTP POST request sent from the device. The received data is analyzed to separate the conditions and emotional state entered by the user. The input is the HTTP request data, and the output is the analyzed conditions and emotional state.

[1746] Step 5:

[1747] Based on the analyzed data, the server sends conditions to the generative AI model and emotional states to the emotion engine. The generative AI model generates an initial fashion image based on the conditions, and the emotion engine adjusts this image based on the emotional state. The input is the conditions and emotional state, and the output is the generated and adjusted fashion image.

[1748] Step 6:

[1749] The server returns the generated and adjusted fashion images and related metadata (size, color, material information, etc.) to the device as an HTTP response. The input is the generated and adjusted image data, and the output is the HTTP response to the device.

[1750] Step 7:

[1751] The device analyzes the fashion image data received from the server and displays it on the user's interface, allowing the user to check the generated image and save or share it. The input is the image data received as an HTTP response, and the output is the display to the user.

[1752] (Application example 2)

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

[1754] In the modern fashion industry, users have to make a lot of effort to narrow down their choices from a wide variety of items. Furthermore, conventional fashion image generation systems lack personalized suggestions based on the user's emotions, making it difficult to find outfits that fit the user's actual needs and mood. In particular, in virtual stores, it is necessary to provide more appropriate fashion suggestions based on emotions when users virtually try on clothes.

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

[1756] In this invention, the server includes means for receiving conditions input to the terminal by the user, means for generating fashion images using a generation AI based on the conditions, means for returning the generated fashion images to the terminal, means for detecting the user's emotions using an emotion recognition engine, means for adjusting the output of the generation AI based on the detected emotions, and means for displaying the adjusted fashion images on the terminal. This allows users to easily obtain fashion images that suit their emotions and moods, and to find the optimal coordination that fits their emotions in a virtual store.

[1757] A "user" refers to an individual who wishes to embody a fashion image.

[1758] "Terminal" refers to electronic devices used by users, such as smartphones, personal computers, and tablets.

[1759] "Conditions" refer to the desires and requests regarding fashion items that a user inputs into the terminal.

[1760] "Generative AI" refers to artificial intelligence that generates new fashion images based on conditions entered by the user.

[1761] "Fashion image" refers to the visual of a specific fashion item generated by generative AI.

[1762] An "emotion recognition engine" is an engine that detects and analyzes user emotions and provides data to adjust the output of generative AI.

[1763] "Server" refers to the central computer system that receives and processes user input data and emotion data.

[1764] "Means for receiving" refers to the function by which the server receives the conditions and emotion data sent from the terminal.

[1765] "Means for generation" refers to the function by which the generative AI creates fashion images based on the received conditions.

[1766] "Means for sending back" refers to the function of sending back the generated fashion image from the server to the terminal.

[1767] "Means for detecting" refers to a function for recognizing a user's emotions and analyzing their emotional state.

[1768] "Adjustment means" refers to a function for optimizing the output of the generative AI based on the emotions detected by the emotion recognition engine.

[1769] "Display means" refers to a function that visually presents the fashion images received by the terminal from the server to the user.

[1770] This invention is a system that generates individual fashion images based on user-entered conditions, recognizes the user's emotions, and provides optimal fashion images based on those emotions. This system consists of a user, a terminal, a server, an emotion recognition engine, and a generation AI model.

[1771] System configuration

[1772] The system includes the following major components:

[1773] 1. User: An individual who wants to embody the image of a fashion item.

[1774] 2. Device: Electronic devices used by users, such as smartphones, computers, and tablets.

[1775] 3. Server: A computer system that includes a generation AI and receives user requests and performs image generation.

[1776] 4. Emotion recognition engine: Recognizes the user's emotions along with the user's input conditions and performs analysis based on those emotions.

[1777] System Operation Overview

[1778] Users input their desired fashion item preferences through their device, and this information, along with the user's emotional state, is sent to the server. The server then uses a generative AI and emotion recognition engine to generate fashion images based on the received preferences and emotional state, and sends the results back to the device. This allows users to receive specific visuals of their desired fashion items and suggestions that fit their emotions.

[1779] Detailed explanation of program processing

[1780] First, the user inputs the desired fashion items into the device interface. At the same time, the user's emotional state is also captured through sensors such as the device's camera and microphone. This information is converted into an appropriate format and sent to the server as an HTTP request.

[1781] The server receives this request and analyzes the input data and emotional data. Conditions and emotional states are extracted from the analyzed data and passed to the generation AI and emotion recognition engine. The generation AI generates fashion images that fit the conditions, and the emotion recognition engine adjusts them based on the emotional state. The generated fashion images are then sent back to the device from the server along with related metadata.

[1782] Hardware and software used

[1783] The system uses the following hardware and software:

[1784] Smartphones, computers, tablets, etc.: the devices through which users interact with the interface.

[1785] Emotion recognition engine: An engine for analyzing user emotions.

[1786] Generative AI model: An artificial intelligence model for generating fashion images.

[1787] HTTP request processing library: A software tool for sending and receiving data.

[1788] Specific examples

[1789] For example, if a user inputs "rock-style jacket" into the device interface and the camera captures an excited expression, the server receives the criteria "rock-style jacket" and the emotional state of "excited." The generative AI generates a rock-style jacket, and the emotion recognition engine suggests more flashy designs and dynamic colors. The final image is sent back to the user for review.

[1790] Example prompt sentence:

[1791] "Fashion item: Rock style jacket, Emotion: Excitement"

[1792] This allows users to receive personalized fashion suggestions based on their emotions.

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

[1794] Step 1:

[1795] The user opens the device interface and inputs the desired fashion item. For example, they might type "rock style jacket" into a text box. The device's camera and microphone also capture the user's emotional state (e.g., smile, surprise, excitement). The input data and emotional data are collected and stored on the device.

[1796] Input: A condition about a fashion item ("rock-style jacket") and the user's emotional state ("excitement")

[1797] Output: Input data and emotion data collected and saved on the device

[1798] Step 2:

[1799] The device converts the collected user input data and emotion data into an appropriate format (e.g., JSON format) and sends it to the server as an HTTP POST request. This data includes the user's desired fashion item conditions and emotional state.

[1800] Input: Input data and emotion data stored on the device

[1801] Output: HTTP POST request sent to the server

[1802] Step 3:

[1803] The server receives the HTTP POST request sent from the device, analyzes the data, extracts conditions and emotional states from the received data, and prepares the data for passing to the generative AI model and emotion recognition engine.

[1804] Input: HTTP POST request sent from the terminal

[1805] Output: Input data to the generative AI model and emotion recognition engine

[1806] Step 4:

[1807] The generative AI model generates fashion images based on the condition data it receives. Furthermore, the emotion recognition engine adjusts the output of the generative AI model based on the emotional state data it receives. For example, if the emotion is "excited," it adjusts the design and color to be more flashy and dynamic.

[1808] Input: Condition data for generative AI models, and emotional state data for emotion recognition engines

[1809] Output: Adjusted fashion image

[1810] Step 5:

[1811] The server returns the adjusted fashion image obtained from the generative AI model and emotion recognition engine, along with related metadata (e.g., size, color, and material information), to the device as an HTTP response.

[1812] Input: Adjusted fashion images and associated metadata

[1813] Output: HTTP response to the device

[1814] Step 6:

[1815] The device analyzes the HTTP response received from the server and displays the fashion image to the user, who can then check the displayed image and save or share it as needed.

[1816] Input: HTTP response received from the server

[1817] Output: Fashion images displayed to the user

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

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

[1820] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the robot 414.

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

[1822] FIG. 9 illustrates an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and behaviors arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

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

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

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

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

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

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

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

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

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

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

[1833] The hardware resource for executing a specific process can be any of the following types of processors: A processor, for example, 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 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.

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

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

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

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

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

[1839] The following is further disclosed regarding the above embodiment.

[1840] (Claim 1)

[1841] A system for generating individual fashion images based on conditions input by a user,

[1842] means for receiving conditions input by the user to the terminal;

[1843] A means for generating a fashion image using a generation AI based on the conditions;

[1844] means for returning the generated fashion image to the terminal;

[1845] A system including:

[1846] (Claim 2)

[1847] 10. The system of claim 1, wherein the terminal formats and transmits user input data to a server.

[1848] (Claim 3)

[1849] 10. The system of claim 1, wherein the server analyzes the received data and prepares it for passing to a generating AI.

[1850] "Example 1"

[1851] (Claim 1)

[1852] A system for generating individual fashion images based on conditions input by a user,

[1853] means for receiving conditions input by the user to the terminal;

[1854] means for said terminal to parse user input data and convert it into an appropriate format;

[1855] means for transmitting the formatted data to a server;

[1856] means for the server to receive formatted data;

[1857] means for the server to analyze the received data and extract conditions;

[1858] A means for generating fashion images using a generative AI model based on the conditions;

[1859] means for returning the generated fashion image to the terminal;

[1860] means for analyzing the image data received by the terminal and displaying it to a user;

[1861] A system including:

[1862] (Claim 2)

[1863] 10. The system of claim 1, wherein the terminal formats and transmits user input data to a server.

[1864] (Claim 3)

[1865] 10. The system of claim 1, wherein the server analyzes the received data and prepares it for passing to a generative AI model.

[1866] "Application Example 1"

[1867] (Claim 1)

[1868] A system for generating individual fashion images based on conditions input by a user,

[1869] means for receiving conditions input by the user to the terminal;

[1870] A means for generating a fashion image using a generation AI based on the conditions;

[1871] means for returning the generated fashion image to the terminal;

[1872] A means for users to virtually try on the generated fashion images;

[1873] A system including:

[1874] (Claim 2)

[1875] 10. The system of claim 1, wherein the terminal formats and transmits user input data to a server.

[1876] (Claim 3)

[1877] 10. The system of claim 1, wherein the server analyzes the received data and prepares it for passing to a generating AI.

[1878] "Example 2: Combining Emotion Engines"

[1879] (Claim 1)

[1880] A system for generating individual fashion images based on conditions and emotional states input by a user and providing the images to the user, comprising:

[1881] means for receiving a condition and an emotional state input by the user into the terminal;

[1882] means for said terminal to format said condition and emotional state into a suitable data format and transmit said data to a server;

[1883] means for the server to analyze the received data and extract the condition and emotional state;

[1884] means for generating fashion images using a generative AI model based on the conditions, and adjusting the fashion images generated by an emotion engine based on the emotional state;

[1885] means for returning the generated and adjusted fashion image to the terminal;

[1886] means for the terminal to display the generated and adjusted fashion image to a user;

[1887] A system including:

[1888] (Claim 2)

[1889] The system of claim 1 , wherein the terminal acquires the emotional state of the user using a sensor.

[1890] (Claim 3)

[1891] 10. The system of claim 1, wherein the emotion engine adjusts the output of the generative AI model based on the emotional state of the user.

[1892] "Application example 2 when combining emotion engines"

[1893] (Claim 1)

[1894] A system for generating individual fashion images based on conditions input by a user,

[1895] means for receiving conditions input by the user to the terminal;

[1896] A means for generating a fashion image using a generation AI based on the conditions;

[1897] means for returning the generated fashion image to the terminal;

[1898] means for detecting a user's emotion using an emotion recognition engine;

[1899] a means for adjusting the output of the generation AI based on the detected emotion;

[1900] means for displaying the adjusted fashion image on the terminal;

[1901] A system including:

[1902] (Claim 2)

[1903] The system of claim 1, wherein the terminal formats the user's input data and emotion data and transmits them to the server.

[1904] (Claim 3)

[1905] 10. The system of claim 1, wherein the server analyzes the received data and prepares it for passing to a generative AI and emotion recognition engine. [Explanation of symbols]

[1906] 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 system for generating individual fashion images based on conditions input by a user, means for receiving conditions input by the user to the terminal; A means for generating a fashion image using a generation AI based on the conditions; means for returning the generated fashion image to the terminal; A system including:

2. 2. The system of claim 1, wherein the terminal formats and transmits user input data to a server.

3. 2. The system of claim 1, wherein the server analyzes the received data and prepares it for passing to a generating AI.

Images