System

Abstract

A system is provided.SOLUTION: Means for receiving input data of a user, means for analyzing the received input data and converting the input data into design elements, means for referring to constraints and rules of a sewing factory and confirming whether the design satisfies the constraints, means for generating a fashion design based on a request of the user and the constraints by using a generative AI model, means for displaying the generated design data to the user and receiving a correction request, means for analyzing the correction request of the user again and generating a design by using the generative AI model again, means for storing the finally determined design data, means for transmitting the order data to a sewing factory as necessary.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] Traditional fashion production has difficulty creating products that meet individual consumer needs, leaving ordinary consumers with a lack of easy ways to create original fashion items that reflect their own ideas. Furthermore, the traditional design process requires consideration of the restrictions and rules of garment factories, making it difficult for individuals to commercialize their designs without specialized knowledge. As a result, consumers have limited opportunities to enjoy unique and original fashion. [Means for solving the problem]

[0005] The present invention solves the aforementioned problems by providing a system that includes: means for receiving user input data; means for analyzing the received input data and converting it into design elements; means for verifying whether the design satisfies the sewing factory's constraints and rules; means for generating a fashion design based on the user's requests and constraints using a generative AI model; means for displaying the generated design data to the user and receiving revision requests; means for reanalyzing the user's revision requests and displaying the regenerated design using the generative AI model; and means for saving the finalized design data and sending it to the sewing factory as order data. This system allows consumers to easily design and produce original fashion items that reflect their own ideas. Furthermore, because the system automates the generation of designs that take into account the sewing factory's constraints, high-quality products can be produced without specialized knowledge.

[0006] "User" refers to a consumer who uses the system to input their design requests and review, modify, and confirm the generated design.

[0007] "Input Data" refers to data, including requests and ideas for fashion items, that a User inputs into the design platform.

[0008] "Design elements" refer to specific design components extracted from user input data, such as color, shape, parts, and details.

[0009] "Sewing factory restrictions and rules" refers to the materials that can be produced in the sewing factory, as well as technical restrictions and guidelines regarding the sewing process.

[0010] "Generative AI models" are artificial intelligence algorithms used to generate fashion designs based on user requests, including generative inverse competitive networks and transformer models.

[0011] "Display means" refers to an interface that visually presents the generated design data to the user and accepts confirmation and correction requests.

[0012] "Modification Request" means a specific request entered by a User to make changes or improvements to a Generated Design.

[0013] "Analysis means" refers to the system functionality that processes user input data and correction requests using text analysis or other algorithms to extract design elements and corrections.

[0014] The "confirm button" refers to an interface element that allows the user to make a final confirmation of the design and input instructions to save it in the system as the final design.

[0015] "Order data" refers to a data set that contains the information necessary for a sewing factory to actually produce a fashion item based on the confirmed design data. [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] The present invention relates to a system that allows users to design original fashion items based on their own design needs and then actually produce them in accordance with the restrictions of a sewing factory.

[0038] System Overview

[0039] The system receives design requests from users, converts them into design elements, and generates the design using a generative AI model. This design is presented visually to the user, who can then input revision requests to generate the design again. The finalized design data is sent to the sewing factory, where production begins.

[0040] Program processing

[0041] 1. Accepting user input

[0042] Users access the platform using a web browser and enter their design ideas and requirements into an input form, including the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs).

[0043] 2. Processing of input content

[0044] The terminal (user device) sends input to the server, which analyzes the received data and uses a text analysis algorithm to break down the user's request into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs).

[0045] 3. Design Generation Using Models

[0046] The server references the sewing factory's constraints and rules, and calls a generative AI model to generate a design based on the user's requests. The generative AI model uses technologies such as generative inverse competitive networks and transformer models. This model generates a design that conforms to the user's requests and constraints.

[0047] 4. Viewing the generated design

[0048] The server sends the generated design data to the user's device, which displays it on a web page, where the user can visually check the generated design.

[0049] 5. User Verification and Correction

[0050] The user can review the generated design and add correction requests if necessary, which are then sent back to the server, which analyzes them and generates the design again using the generative AI model.

[0051] 6. Finalize and save the design

[0052] Once the user is satisfied with the final design, they press the "Confirm" button. The server stores this design data and, if necessary, sends it to the sewing factory as order data. This data includes design details, material information, production specifications, etc.

[0053] Specific examples

[0054] For example, if a user requests a "blue hoodie with a zipper on the hood and ribbed cuffs," the process is as follows:

[0055] 1. A user accesses the design platform, enters their request, and submits it.

[0056] 2. The device sends the input data to the server.

[0057] 3. The server parses the data and breaks it down into design elements.

[0058] 4. The server references the sewing factory's constraints and generates the design using a generative AI model.

[0059] 5. The server sends the generated design data to the user's device.

[0060] 6. The device displays the design for the user to review.

[0061] 7. If the user enters a modification request, the data is sent to the server.

[0062] 8. The server analyzes the modification request and regenerates the design.

[0063] 9. Once the user has finalized the design to their satisfaction, the server saves the design data and sends it to the sewing factory as order data.

[0064] In this way, original fashion items based on the user's requests are efficiently generated and manufactured.

[0065] The processing flow will be explained below.

[0066] Step 1:

[0067] Users access the design platform using a web browser and enter their requirements into a design form, including color, shape, material, and specific design elements (e.g., a zipper on the hood, ribbed cuffs).

[0068] Step 2:

[0069] The device sends the input data to the server, which includes the design requests entered by the user.

[0070] Step 3:

[0071] The server parses the input data it receives, using a text analysis algorithm to break down the user's request into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs).

[0072] Step 4:

[0073] The server compares the parsed design elements with the constraints and rules of the sewing factory to ensure that the request meets the constraints, ensuring that the design is actually manufacturable.

[0074] Step 5:

[0075] The server calls a generative AI model, such as a generative inverse competitive network or a transformer model, to generate a fashion design based on the user's requests and constraints.

[0076] Step 6:

[0077] The server sends the generated design data to the user's device, which includes a visual representation of the design and detailed specifications.

[0078] Step 7:

[0079] The device displays the received design data on a web page, allowing the user to check the generated design.

[0080] Step 8:

[0081] The user checks the displayed design and inputs any corrections that are needed (e.g., "The zipper on the hood should be a little longer.") The correction request is then sent back to the server.

[0082] Step 9:

[0083] The server analyzes the modification request and calls the generative AI model again to regenerate the model reflecting the modifications.

[0084] Step 10:

[0085] The server transmits new design data generated based on the modification request to the user's terminal, which then displays it again.

[0086] Step 11:

[0087] The user confirms the final design that satisfies them and presses the "Confirm" button, which confirms the final design.

[0088] Step 12:

[0089] The server stores the finalized design data and, if necessary, sends it to the sewing factory as order data, which includes details of the design, material information, production specifications, etc.

[0090] The above is the specific process flow from user input to requesting the production of a fashion item.

[0091] Example 1

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

[0093] Conventional fashion design generation systems have difficulty efficiently integrating user requests with the constraints of sewing factories. It is also difficult to modify and check generated designs in real time, resulting in a poor user experience. Furthermore, the process of analyzing user design requests in detail and appropriately reflecting them in the generation AI model requires advanced technology, which increases the complexity of the system.

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

[0095] In this invention, the server includes means for receiving user input data, means for analyzing the received input data and converting it into design elements, means for referencing the sewing factory's constraints and rules to confirm whether the design satisfies the constraints, means for generating a fashion design based on the user's requests and constraints using a generative AI model, means for displaying the generated design data to the user and receiving revision requests, means for reanalyzing the user's revision requests and displaying the design regenerated by the generative AI model, means for saving the finalized design data and transmitting it to the sewing factory as order data as necessary, means for transmitting the received design data to the user's terminal using a web browser, means for saving the design elements in a database and retrieving the sewing factory's constraints from an internal database, and means for receiving user input in real time and waiting for the click of a send button. This allows for efficient integration of user and sewing factory requests and allows for real-time design revision and confirmation.

[0096] "Means for receiving user input data" refers to providing a function that allows users to enter design ideas and requests into an input form using a web browser.

[0097] The "means for analyzing received input data and converting it into design elements" means a means for analyzing input user requests using a text analysis algorithm and breaking them down into specific design elements.

[0098] "Means for referencing the restrictions and rules of the sewing factory and verifying that the design meets the restrictions" refers to retrieving restrictions such as available materials, colors, and sewing patterns at the sewing factory from an internal database and verifying that the generated design complies with these restrictions.

[0099] "Means for generating fashion designs based on user requests and constraints using a generative AI model" refers to the use of a generative AI model such as a generative inverse competitive network or a transformer model to automatically generate fashion designs that take into account user requests and the constraints of garment factories.

[0100] The "means for displaying the generated design data to the user and receiving requests for revisions" means sending the generated design data to the user's device, enabling the user to visually check the design on a web browser, and further enabling the user to receive requests for revisions.

[0101] "Means for re-analyzing the user's request for revisions and displaying a regenerated design using a generative AI model" refers to re-analyzing the user's request for revisions, generating a new design using a generative AI model, and displaying it to the user again.

[0102] "Means for saving finalized design data and transmitting it to a sewing factory as order data as needed" means enabling a user to save finalized design data in a database and transmit it to a sewing factory as order data as needed.

[0103] "Means for transmitting received design data to the user's terminal using a web browser" means transmitting the generated design data to the user's terminal via a web browser.

[0104] The "means for storing design elements in a database and retrieving sewing factory restrictions from an internal database" means storing the analyzed design elements in a database and retrieving sewing factory restrictions from an internal database.

[0105] "Means for receiving user input in real time and waiting for the send button to be clicked" means receiving the information the user is entering into the input form in real time and waiting for the send button to be clicked.

[0106] This invention relates to a system that allows users to design original fashion items based on their own design requests and then actually produce them in accordance with the constraints of a sewing factory. The system of the present invention has the function of receiving design requests from users, converting them into design elements, and generating a design using a generative AI model. This design is presented visually to the user, and the user can input correction requests to regenerate the design. The finalized design data is sent to the sewing factory, where production begins.

[0107] Specific Embodiments of the System

[0108] Hardware and Software Configuration

[0109] User: Accesses the system platform using a web browser. User devices include PCs and smartphones.

[0110] Terminal: A device that transmits data entered by a user to a server. Generally, this is a PC or smartphone.

[0111] Server: Equipped with a central processing unit (CPU), data analysis software, and generative AI models. Specific software used includes NLTK and spaCy (text analysis), and TensorFlow and PyTorch (generative AI models).

[0112] Generative AI models: Generative inverse competitive networks (GANs) and transformer models are used to generate designs based on user preferences and the constraints of the garment factory.

[0113] Processing Steps

[0114] 1. Accepting user input

[0115] A user logs in to the system's platform using a web browser and enters their desired item type (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs) into an input form.

[0116] The terminal receives the input data in real time and waits for the send button to be clicked.

[0117] 2. Processing of input content

[0118] The user clicks the submit button, and the terminal sends the input data to the server in XML or JSON format.

[0119] The server parses the received data and uses text analysis algorithms such as NLTK or spaCy to break down user requests into individual design elements.

[0120] 3. Design generation using generative AI models

[0121] The server retrieves the sewing factory's constraints from an internal database, including information such as material type, available colors, and sewing patterns.

[0122] The server calls the generative AI model and generates a design based on the user's requests and constraints.

[0123] Example prompt: "Generate a blue hoodie with a zipper on the hood and ribbed cuffs."

[0124] The server saves the generated design data in a certain format (e.g., SVG or PNG).

[0125] 4. Viewing the generated design

[0126] The server sends the generated design data to the user's device, which then displays the received design data on a web page. Users can visually check the design using HTML5 or JavaScript libraries (e.g., Canvas API, D3.js).

[0127] 5. User Verification and Correction

[0128] The user checks the displayed design and adds correction requests to the input form if necessary. They enter specific correction requests, such as "I want the hood size to be larger."

[0129] The terminal sends a modification request to the server, which analyzes it and displays the regenerated design again to the user.

[0130] 6. Finalize and save the design

[0131] When the user is satisfied with the final design, he / she clicks the "Confirm" button. The device sends the confirmation information to the server.

[0132] The server stores the finalized design data in a database and sends it to the sewing factory as order data. This order data includes design details, material information, and production specifications. The data may be sent using protocols such as API or FTP.

[0133] The server sends the user an order confirmation email.

[0134] Specific examples

[0135] For example, if a user requests a "red T-shirt with large pockets on the front and ribbed cuffs," the following steps are taken:

[0136] 1. The user accesses the platform, enters their request and submits it.

[0137] 2. The device sends the input information in JSON format to the server and clicks the send button.

[0138] 3. The server analyzes the data and breaks it down into design elements (e.g., "Color = red, Item = T-shirt, Detail 1 = large pocket on the front, Detail 2 = ribbed cuffs").

[0139] 4. The server retrieves the constraints of the sewing factory and inputs the prompt statement "A red T-shirt with a large pocket on the front and ribbed cuffs" into the generative AI model.

[0140] 5. The server saves the generated design data in PNG format and sends it to the user's device.

[0141] 6. The user reviews the design and submits a request for modification, such as "move the pocket to the left chest."

[0142] 7. The server analyzes the modification request, regenerates the design using the generative AI model, and sends it to the user's device.

[0143] 8. Once the user is satisfied with the design, they send it to the server as "confirmed," and the server saves the design data and sends it to the sewing factory as order data.

[0144] In this way, users can efficiently design original fashion items based on their own desires and even place an order.

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

[0146] Step 1: Receive user input

[0147] Users log in to the system platform using a web browser, for example, from a PC or smartphone.

[0148] The user inputs their design requirements (e.g., item type, color, and design elements) into an input form, such as "a blue hoodie with a zipper on the hood and ribbed cuffs."

[0149] The terminal receives this input data in real time and waits for the send button to be clicked.

[0150] Input: User's design request data (text format)

[0151] Output: Input data is retained until you click the submit button.

[0152] Step 2: Send and parse input

[0153] The user clicks the submit button.

[0154] The terminal sends input data to the server in XML or JSON format, which includes the requests entered by the user.

[0155] The server then analyzes the received data using a text analysis algorithm (such as NLTK or spaCy) to break down the request into individual design elements.

[0156] Specifically, it is converted into elements such as "color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs."

[0157] Input: User input data (JSON format)

[0158] Output: Decomposed design element data (internal data structure)

[0159] Step 3: Refer to the restrictions of the garment factory

[0160] The server retrieves the garment factory's constraints from an internal database, including material types, available colors, sewing patterns, etc.

[0161] Input: None (reference to internal database)

[0162] Output: Garment factory constraints data

[0163] Step 4: Generate a design using a generative AI model

[0164] The server calls a generative AI model (GAN or Transformer model) based on the acquired constraints of the sewing factory and the user's requests, and inputs a prompt statement.

[0165] Example prompt: "Generate a blue hoodie with a zipper on the hood and ribbed cuffs."

[0166] The server saves the generated design data in SVG or PNG format.

[0167] Input: User request data, sewing factory restriction data

[0168] Output: Generated design data (SVG or PNG format)

[0169] Step 5: View the generated design

[0170] The server transmits the generated design data to the user's terminal.

[0171] The device then displays the received design data on a web page, allowing users to visually check it using HTML5 and JavaScript libraries (e.g., Canvas API, D3.js).

[0172] Input: Generated design data (SVG or PNG format)

[0173] Output: Design displayed in browser

[0174] Step 6: Receive user confirmation and correction requests

[0175] The user checks the generated design and adds modifications to specific parts (e.g., changing the position of the pocket) in the input form.

[0176] The terminal sends a modification request to the server.

[0177] The server again analyzes the modification request and generates a new design using the generative AI model.

[0178] The server transmits the newly generated design data to the user terminal again and displays it again.

[0179] Input: User's correction request (text format)

[0180] Output: Regenerated design data (SVG or PNG format)

[0181] Step 7: Finalize and save your design

[0182] The user confirms that the design is satisfactory and clicks the "Confirm" button.

[0183] The terminal transmits the determination information to the server.

[0184] The server stores the confirmed design data in a database.

[0185] The server sends the design data to the sewing factory as order data as needed, using API and FTP protocols.

[0186] The server sends the user an order confirmation email.

[0187] Input: Finalized design data

[0188] Output: Save to database, send order data, confirmation email

[0189] Through the above processing steps, users can smoothly design original fashion items and complete their orders.

[0190] (Application example 1)

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

[0192] Previous fashion design systems were difficult to use or took a long time to reflect user requests. Furthermore, when users checked and revised their designs, they had problems receiving immediate feedback on the sewing factory's restrictions and feasibility. Furthermore, after the design was finalized, a separate purchasing process was required, resulting in poor user convenience.

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

[0194] In this invention, the server includes means for receiving user input data, means for analyzing the received input data and converting it into design elements, means for transmitting the analyzed design elements to the server via a communication network, means for referencing the sewing facility's constraints and rules and confirming whether the design satisfies the constraints, means for generating a fashion design based on the user's requests and constraints using a generative AI model, means for displaying the generated design data on the user's mobile device and receiving revision requests, means for re-analyzing the user's revision requests and displaying the design regenerated by the generative AI model on the user's mobile device, means for saving the finalized design data and transmitting it to the sewing facility as order data as needed, and means for purchasing items designed by the user. This significantly improves user convenience, enabling the quick and efficient creation and purchase of fashion items based on the user's own design preferences.

[0195] "User" refers to an individual who uses the system to design and ultimately purchase their own fashion items.

[0196] "Input data" refers to information such as the type, color, and design elements of a fashion item that a user provides to the system.

[0197] "Text analysis algorithm" refers to the technology that analyzes user input data and converts it into the necessary design elements.

[0198] "Server" refers to the central computing device that receives and analyzes user input data and performs design generation.

[0199] A "sewing facility" refers to a factory or work space where the fashion items designed by users are actually produced.

[0200] "Restrictions and Rules" refers to the technical and operational restrictions and regulations in the garment facility.

[0201] "Generative AI model" refers to artificial intelligence technology that generates optimal fashion designs based on user preferences and sewing facility constraints.

[0202] "Design Elements" refers to various specific design requirements (e.g., color, shape, details, etc.) provided by the user as input data.

[0203] "Modification Request" means a user's instruction for a change or adjustment to the generated design.

[0204] "Mobile Device" means the mobile device used by a User to access the System, input design elements, and review and modify generated designs.

[0205] "Order data" refers to data including production instructions and necessary information sent to a sewing facility based on the finalized design data.

[0206] "Purchase method" refers to the mechanisms and functions that allow users to order and complete purchases of their own designed fashion items online.

[0207] The system of the present invention provides a concrete means for users to customize, efficiently design and purchase their own fashion items.

[0208] Hardware and software used

[0209] Hardware:

[0210] Mobile devices such as smartphones and tablets

[0211] Central server (cloud-based or on-premise server)

[0212] software:

[0213] Application frameworks (React Native, Flutter)

[0214] Text analysis algorithms (spaCy, NLTK)

[0215] Generative AI models (GPT-4, DALL-E)

[0216] Communication protocol (HTTPS)

[0217] Database (MySQL, PostgreSQL)

[0218] Specific operation of the system

[0219] 1. Accept user input data

[0220] First, the user inputs their fashion item customization requirements using a dedicated application on their mobile device. For example, they can input a request for a "red T-shirt with a pocket on the front and stripes on the cuffs." The user's input data is sent to the server in text format.

[0221] 2. Converting to design elements

[0222] The server analyzes the received input data using a text analysis algorithm (e.g., spaCy or NLTK) and breaks it down into design elements such as:

[0223] Item: T-shirt

[0224] Color: Red

[0225] Detail 1: Front pocket

[0226] Detail 2: Stripes on the cuffs

[0227] 3. Design generation and confirmation

[0228] The server generates fashion designs using a generative AI model (e.g., GPT-4, DALL-E) based on the analyzed design elements and the constraints and rules of the sewing facility. The generated designs are then sent back to the user's mobile device, where they can be visually confirmed.

[0229] 4. Correction Requests and Regeneration

[0230] If a user requests modifications to the design, they re-enter their specific instructions (e.g., "make the pockets smaller") and send them to the server. The server analyzes the modifications and uses a generative AI model to generate a re-created design, allowing the user to make any number of modifications.

[0231] 5. Finalize the design and place an order

[0232] Once the user has finalized the design and is satisfied with it, they press the confirm button. The server stores this design data and sends it to the sewing facility as order data. This order data includes design details, material information, production specifications, etc.

[0233] 6. Purchase

[0234] Users can purchase the items they have designed directly within the application, and the purchasing process is intuitive and very convenient for users.

[0235] Specific examples

[0236] For example, if a user requests a "red T-shirt with a pocket on the front and stripes on the cuffs," the prompt might look like this:

[0237] User Request:

[0238] Item: T-shirt

[0239] Color: Red

[0240] Detail 1: Front pocket

[0241] Detail 2: Stripes on the cuffs

[0242] This prompt is then fed into the generative AI model, which then presents the resulting design to the user. If the user requests a modification (e.g., "Make the pockets smaller"), the new prompt becomes:

[0243] User Request:

[0244] Item: T-shirt

[0245] Color: Red

[0246] Detail 1: Small pocket on the front

[0247] Detail 2: Stripes on the cuffs

[0248] In this way, by creating a system in which designs are generated based on user requests, checked and revised, and finally ordered from a sewing facility, user convenience and satisfaction can be improved.

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

[0250] Step 1:

[0251] The user uses a dedicated application on their mobile device to input their requests for customizing fashion items. For example, they might input a request in text format such as "a red T-shirt with a pocket on the front and stripes on the cuffs." The input data is generated and sent from the device to the server.

[0252] Step 2:

[0253] The server analyzes the received input data using a text analysis algorithm (e.g., spaCy, NLTK). The input data, "a red T-shirt with a pocket on the front and stripes on the cuffs," is analyzed and converted into the following design elements:

[0254] Item: T-shirt

[0255] Color: Red

[0256] Detail 1: Front pocket

[0257] Detail 2: Stripes on the cuffs

[0258] After the design elements are extracted, a request is generated to reference the constraints and rules.

[0259] Step 3:

[0260] The server references the constraints and rules of the sewing facility to verify that the design meets the constraints. For example, it checks whether "stripes on the cuffs" are technically acceptable to the sewing factory and evaluates whether they meet certain constraints. Based on this information, it generates prompts for the generative AI model.

[0261] Step 4:

[0262] The server uses a generative AI model (e.g., GPT-4, DALL-E) to generate a fashion design based on the user's requirements and the constraints of the sewing facility. The server receives the prompt "User requirement: Item: T-shirt, Color: Red, Detail 1: Pocket on front, Detail 2: Stripes on cuffs" and retrieves the generated design image data. The generated design is then sent from the server to the user's mobile device.

[0263] Step 5:

[0264] The user checks the generated design on the mobile device. Depending on the displayed design, the user inputs a modification request. For example, the user inputs a modification request such as "make the pockets smaller" and sends it from the device to the server. The modification request is processed as new input data.

[0265] Step 6:

[0266] The server analyzes the modification request again (e.g., using spaCy or NLTK) and generates a regenerated design using the generative AI model. The modified prompt, "User wants: Item: T-shirt, Color: Red, Detail 1: Small pocket on the front, Detail 2: Stripes on the cuffs," is input to the model and new design image data is obtained. The regenerated design is then sent back to the user's mobile device.

[0267] Step 7:

[0268] The user confirms the final design and presses the confirm button. The server saves the final design data and generates order data, which includes design details, material information, production specifications, etc. The order data is sent to the sewing facility, and production begins.

[0269] Step 8:

[0270] Users can purchase the items they design directly within the application. The purchasing process is conducted through an intuitive interface, and the final output is a purchase confirmation data that is sent to the server and notified to the user.

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

[0272] The present invention relates to a system that incorporates an emotion engine that recognizes the user's emotions, designs original fashion items based on the user's requests and emotions, and actually produces them in accordance with the restrictions of the sewing factory.

[0273] System Overview

[0274] The system receives design requests from users, recognizes their emotions using an emotion engine, converts them into design elements, and generates designs using a generative AI model. The generated designs are presented visually to the user, who can then regenerate the design by inputting correction requests and emotional feedback. The finalized design data is sent to the sewing factory, where production begins.

[0275] Program processing

[0276] 1. Accepting user input

[0277] Users access the design platform using a web browser and enter their design ideas and requirements into an input form, including the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs).

[0278] 2. Recognize user emotions

[0279] For emotion recognition, the device uses a webcam and microphone to capture the user's facial expressions and tone of voice, which are then sent to the emotion engine.

[0280] 3. Emotional Data Processing

[0281] The server uses an emotion engine to analyze the user's emotions from the captured data, for example, by using facial expression analysis algorithms or voice analysis algorithms to identify the user's emotional state (e.g., joy, sadness, surprise, etc.).

[0282] 4. Input and Emotional Data Processing

[0283] The server analyzes the user's input data and emotional data, and uses a text analysis algorithm to break down the user's requests into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs). The emotional data is used to adjust and optimize the design elements.

[0284] 5. Design Generation Using Models

[0285] The server references the sewing factory's constraints and rules, and calls a generative AI model to generate a design based on the user's requests and emotional data. Generative AI models use generative inverse competitive networks and transformer models, among other things. Emotional data is reflected in the color and design details.

[0286] 6. Viewing the generated design

[0287] The server sends the generated design data to the user's device, which displays it on a web page, where the user can visually check the generated design.

[0288] 7. User Verification and Correction

[0289] The user reviews the displayed design and enters specific changes based on their emotional state in the "Modification Request Form" (e.g., "The zipper on the hood should be a little longer"). The modification request and emotional data are then sent back to the server.

[0290] 8. Requesting corrections and reprocessing emotion data

[0291] The server analyzes the modification request and regenerates the design using the generative AI model while referring to the emotional data, thereby providing a design that reflects the user's emotional state.

[0292] 9. Finalize and save the design

[0293] Once the user is satisfied with the final design, they press the "Confirm" button. The server stores this design data and, if necessary, sends it to the sewing factory as order data. This data includes design details, material information, production specifications, etc.

[0294] Specific examples

[0295] For example, if a user requests a "blue hoodie with a zipper on the hood and ribbed cuffs," and the system recognizes that the user is expressing a feeling of satisfaction (happiness), it will adjust the design to reflect that emotion, using more detail and colors that emphasize the user's emotions. The design will then be presented to the user.

[0296] In this way, by reflecting the user's emotions, it becomes possible to design original fashion items that are more personal and satisfying.

[0297] The processing flow will be explained below.

[0298] Step 1:

[0299] Users access the design platform using a web browser and enter their design ideas and requirements into an input form, including the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs).

[0300] Step 2:

[0301] The device sends the input data to the server, which includes the design requests entered by the user.

[0302] Step 3:

[0303] For emotion recognition, the device uses a webcam and microphone to capture the user's facial expressions and tone of voice, which are then sent to the emotion engine in real time.

[0304] Step 4:

[0305] The server uses an emotion engine to analyze the user's emotions from the captured data, for example, by using facial expression analysis algorithms or voice analysis algorithms to identify the user's emotional state (e.g., joy, sadness, surprise, etc.).

[0306] Step 5:

[0307] The server analyzes the user's input data and emotional data, and uses a text analysis algorithm to break down the user's requests into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs). The emotional data is used to adjust and optimize the design elements.

[0308] Step 6:

[0309] The server references the sewing factory's constraints and rules, and calls a generative AI model to generate a design based on the user's requests and emotional data. Generative AI models use generative inverse competitive networks and transformer models, among other things. Emotional data is reflected in the color and design details.

[0310] Step 7:

[0311] The server sends the generated design data to the user's device, which includes a visual representation of the design and detailed specifications.

[0312] Step 8:

[0313] The device displays the received design data on a web page, where the user can visually check the generated design.

[0314] Step 9:

[0315] The user reviews the displayed design and enters specific changes based on their emotional state in the "Modification Request Form" (e.g., "The zipper on the hood should be a little longer"). The modification request and emotional data are then sent back to the server.

[0316] Step 10:

[0317] The server analyzes the modification request and regenerates the design using the generative AI model while referring to the emotional data, thereby providing a design that reflects the user's emotional state.

[0318] Step 11:

[0319] The server transmits new design data generated based on the modification request to the user's terminal, which then displays it again.

[0320] Step 12:

[0321] The user confirms the final design that satisfies them and presses the "Confirm" button, which confirms the final design.

[0322] Step 13:

[0323] The server stores the finalized design data and, if necessary, sends it to the sewing factory as order data, which includes details of the design, material information, production specifications, etc.

[0324] The above is the specific process flow for requesting the production of a fashion item, combining user input and emotion recognition.

[0325] Example 2

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

[0327] Conventional fashion design generation systems create designs based solely on the user's requests, making it difficult to reflect the user's emotions and latent needs. They also have problems with not being able to efficiently accommodate user requests for revisions, resulting in lower user satisfaction. Furthermore, it is difficult to generate designs that take into account the constraints of a sewing factory, often requiring numerous adjustments during the actual production process.

[0328] The specific processing by the specific processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes means for receiving user input data, means for collecting user emotional data using a webcam or microphone, means for analyzing the collected emotional data and identifying the user's emotional state, means for integrating the received input data and the analyzed emotional data and converting them into design elements, means for referring to the sewing factory's restrictions and rules and checking whether the design satisfies the restrictions, means for generating a fashion design based on the user's requests, emotional data, and restrictions using a generative AI model, means for displaying the generated design data to the user and receiving revision requests, means for re-analyzing the user's revision requests and emotional data and displaying the design regenerated by the generative AI model, and means for saving the finalized design data and, if necessary, transmitting it as order data to the sewing core industry. This enables personalized design generation that reflects the user's emotions, efficient revision support, and smooth production at the sewing factory.

[0329] "User input data" refers to requests and specification information regarding fashion items that users input through the design platform.

[0330] "Emotional data" refers to data on a user's facial expressions and voice collected using a webcam or microphone, and is used to analyze the user's emotional state.

[0331] An "emotion engine" is a system that includes algorithms and programs for analyzing collected emotional data and identifying the user's emotional state.

[0332] "Design elements" are information that refers to the characteristics and details of specific fashion items generated based on user input data and emotional data.

[0333] "Generative AI model" means an artificial intelligence model used to generate fashion designs based on user preferences, emotional data, and garment factory constraints, including a generative inverse competitive network or a transformer model.

[0334] "Sewing factory constraints" refers to information about factory equipment, technical constraints, and specifications that must be taken into consideration when actually producing fashion items.

[0335] "Order data" refers to data sent to a sewing factory that includes the finalized design data, necessary material information, production specifications, etc.

[0336] A "modification request" is a requirement that a user inputs in the form of specific instructions for changes to the generated design.

[0337] A "webcam" is an image input device used to collect facial expression data of a user.

[0338] A "microphone" is an audio input device used to collect data of a user's voice.

[0339] The present invention relates to a system for designing original fashion items using user emotional data and having the designs produced at a garment factory. This system involves a series of processes, starting with a user accessing a design platform and inputting their design requirements, followed by generating a design using an emotion recognition and generative AI model, and finally sending the finalized design to the garment factory.

[0340] System configuration

[0341] Hardware:

[0342] Terminal: The computer through which the user provides input.

[0343] Webcam: Image input device for collecting user facial expression data

[0344] Microphone: A voice input device for collecting data on the user's voice.

[0345] Server: A computer system that analyzes data and runs generative AI models.

[0346] software:

[0347] Design platform: a web application that provides the user interface

[0348] Emotion engine: Algorithms for analyzing user emotion data

[0349] Text analysis algorithms: Software that analyzes user input and converts it into design elements

[0350] Generative AI models: Artificial intelligence models for generating designs using generative inverse competitive networks (GANs) and transformer models.

[0351] Collecting user input and sentiment data

[0352] Users access the design platform and enter their design requirements into an input form. For example, they can enter specific requirements such as "a blue hoodie with a zipper on the hood and ribbed cuffs." At this time, the device's webcam and microphone are activated, and facial and voice data from the user is collected in real time.

[0353] Data analysis and design generation

[0354] The server uses an emotion engine to analyze the user's emotions from the collected facial and voice data. The analysis results indicate, for example, that the user is feeling "joy." The server then integrates the user's input data with the analyzed emotion data and converts it into design elements using a text analysis algorithm.

[0355] The server then calls up a generative AI model, taking into account the sewing factory's constraints, to generate a design based on the user's requests and emotional data. For example, the generative AI model might incorporate bright colors and detailed design elements to reflect the emotion of "joy."

[0356] View and modify the design

[0357] The generated design data is sent from the server to the user's device and displayed on a web page. The user can review the displayed design and input correction requests as needed. The correction requests and emotion data are sent back to the server, where the generative AI model regenerates the design, and the new design is provided to the user.

[0358] Final design confirmation and order placement

[0359] Once the user has confirmed the final design and clicked the "confirm" button, the server saves the design data. The saved design data is then sent to the sewing industry as order data. This data includes details of the design, material information, production specifications, etc.

[0360] Specific examples

[0361] For example, if a user requests a "blue hoodie with a zipper on the hood and ribbed cuffs," and the system recognizes that the user is expressing a feeling of satisfaction (happiness), it will adjust the design to reflect that emotion, using more detail and colors that emphasize the user's emotions. The design will then be presented to the user.

[0362] Prompt Sentence Examples

[0363] User input data:

[0364] Item Type: Hoodie

[0365] Color: Blue

[0366] Design elements:

[0367] Zipper on hood

[0368] Ribbed cuffs

[0369] User Emotion Data: Joy

[0370] Prompt statement:

[0371] "Based on the user's desire and emotional state, generate a design for a blue hoodie with a zippered hood and ribbed cuffs. The user is expressing the emotion of joy, so emphasize the design details and color."

[0372] By using these techniques, it is possible to design original fashion items that are personal and highly satisfying, reflecting the user's emotions.

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

[0374] Step 1: Receive user input

[0375] A user accesses the design platform using a web browser and inputs their design requirements. The input includes detailed information such as the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on the hood, ribbed cuffs). The input data is sent to the terminal through an input form. The terminal is responsible for sending this data to the server. Example of input data: "A blue hoodie with a zipper on the hood and ribbed cuffs."

[0376] Step 2: Collecting emotion data

[0377] The device activates the webcam and microphone to collect the user's facial and voice data. This data is captured in real time and sent to the emotion engine. The input data includes the user's facial images and voice recordings. The output data is the emotion data sent to the server.

[0378] Step 3: Analyze the emotion data

[0379] The server uses an emotion engine to analyze the collected facial expression data and voice data to identify the user's emotional state. It uses a facial expression analysis algorithm to analyze the facial expression data and a voice analysis algorithm to analyze the voice data. The resulting analysis results identify the user's emotional state (e.g., joy, sadness, surprise, etc.). The input data are facial expression and voice data, and the output data is the emotional state (e.g., the user is showing the emotion of "joy").

[0380] Step 4: Integrating and processing input and emotion data

[0381] The server combines the user's input data with the analyzed emotion data and converts it into design elements using a text analysis algorithm. The input data is broken down into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs), and the emotion data is used to adjust the design elements. The input data are the user's desires and emotion data, and the output data are the analyzed design elements.

[0382] Step 5: Generate a design using the model

[0383] The server references the sewing factory's restrictions and rules and generates designs using a generative AI model. The generative AI model uses a generative inverse competitive network (GAN) or a transformer model to generate optimal designs based on the user's requests and emotional data. The input data are design elements and emotional data, and the output data is the generated design.

[0384] Step 6: View the generated design

[0385] The server sends the generated design data to the user's device, and the device visually displays the design on a web page, where the user can check the generated design. The input data is the generated design data, and the output data is the design displayed to the user.

[0386] Step 7: Verify and modify users

[0387] The user checks the displayed design and enters specific changes in the "Modification Request Form." For example, they can enter specific instructions such as "I want the zipper on the hood to be a little longer." The modification request and emotion data are sent back to the server. The input data are the modification request and emotion data, and the output data is the updated input data.

[0388] Step 8: Request corrections and reprocess emotion data

[0389] The server analyzes the revision request and regenerates the design using the generative AI model while referring to the emotional data. This generates a revised design that reflects the user's emotional state. The input data are the revision request and emotional data, and the output data is the regenerated design.

[0390] Step 9: Finalize and save your design

[0391] The user finally confirms the design to their satisfaction and presses the "confirm" button. The server saves this design data and sends it to the sewing industry as order data. The order data includes design details, material information, production specifications, etc. The input data is the confirmed design data, and the output data is the saved design data and order data.

[0392] (Application example 2)

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

[0394] In recent years, the demand for original fashion items has increased, and users tend to want designs based on their own emotions. However, current systems cannot recognize users' emotions and reflect them in the design, so they cannot fully meet this demand. Furthermore, even if users request revisions, the design is not regenerated taking into account their emotional data, which results in a decrease in user satisfaction.

[0395] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving user input data, means for analyzing the received input data and converting it into design elements, means for recognizing and analyzing the user's emotional data, means for adjusting the design elements based on the emotional data, means for referencing the sewing factory's constraints and rules and confirming whether the design satisfies the constraints, means for generating a fashion design based on the user's requests, constraints, and emotional data using a generative AI model, means for displaying the generated design data to the user and receiving revision requests, means for reanalyzing the user's revision requests and emotional data and displaying the design regenerated by the generative AI model, and means for saving the finalized design data and, if necessary, transmitting it to the sewing factory as order data. This makes it possible to generate and modify designs that reflect the user's emotions.

[0396] "Means for receiving user input data" refers to means for providing an interface for users to input information such as design requests and ideas into the system.

[0397] "Means for analyzing received input data and converting it into design elements" refers to the algorithms or processes used to break down the input data received from the user into individual elements, analyze them, and convert them into design elements.

[0398] "Means for recognizing and analyzing user emotional data" refers to hardware and software for collecting and analyzing user emotions using technologies such as facial recognition and voice analysis.

[0399] "Means for adjusting design elements based on emotional data" refers to a mechanism for optimizing and adjusting design elements based on acquired emotional data, making it possible to fine-tune the design to reflect the user's emotions.

[0400] "Means of referencing the constraints and rules of the garment factory and verifying that the design meets the constraints" refers to a process or system for referencing the technical and manufacturing constraints and rules of the garment factory and verifying that the generated design meets these conditions.

[0401] "Means for using a generative AI model to generate fashion designs based on user requests, constraints, and emotional data" refers to means for using a generative AI model such as a generative inverse competitive network or a transformer model to create fashion designs based on user requests, constraints of a garment factory, and emotional data.

[0402] "Means for displaying the generated design data to the user and receiving revision requests" refers to means for visually presenting the generated design data to the user and providing an interface for inputting revision requests from the user.

[0403] "Means for re-analyzing the user's revision requests and emotional data, and displaying a design re-generated by the generative AI model" refers to means for analyzing the user's revision requests and emotional data, re-generating a design using the generative AI model, and presenting it to the user.

[0404] "Means for saving the finalized design data and sending it to the sewing factory as order data as necessary" refers to the process for saving the design data that has been finalized by the user in the system and sending that data to the sewing factory as a production request.

[0405] The present invention is a system that recognizes a user's emotions and designs original fashion items based on those emotions. Specific embodiments of the system will be described below.

[0406] The system mainly consists of a terminal that receives user input data, a means for recognizing and analyzing emotional data, a means for generating designs using a generative AI model, and an interface for displaying and modifying the generated design data.

[0407] Configuration details

[0408] 1. Receiving and analyzing input data

[0409] A device (such as a smartphone or head-mounted display) receives design requests and ideas from users through an input form. The user's input data is sent to a server, which then analyzes the data using a text analysis algorithm (such as natural language processing technology) and converts it into design elements.

[0410] 2. Emotion Data Recognition and Analysis

[0411] The device's built-in camera and microphone are used to capture the user's facial expressions and tone of voice in real time. This emotional data is then analyzed using libraries such as TensorFlow and OpenCV. The server then determines the user's emotional state based on this emotional data.

[0412] 3. Design Generation

[0413] The server invokes a generative AI model using a generative inverse competitive network (GAN) or a transformer model based on the user's input data and emotional data. The generative AI model generates a design that reflects the user's wishes and emotional state. It also references the sewing factory's constraints and rules, adjusting the generated design to meet these conditions.

[0414] 4. View and modify the design

[0415] The generated design data is then sent back to the device and visually presented to the user. The user can then input any modifications they wish to make to the design into the system. The modifications are then analyzed again by the server, and the generative AI model generates a re-created design based on the emotion data.

[0416] 5. Finalize and save the design

[0417] Once the user is satisfied with the final design and presses the "confirm" button, the server saves the design data and sends it to the sewing factory as order data, including design details, material information, and production specifications.

[0418] Specific examples

[0419] For example, a user uses a smartphone to enter the following request:

[0420] "I want a red dress with a heart pattern scattered all over it."

[0421] If the user responds to this input with an emotion of "happiness," the system generates a warm color scheme and design that reflects that emotion. The user reviews the design and can enter the following if further adjustments are needed:

[0422] "Make the heart pattern bigger and add ruffles to the bottom of the dress."

[0423] The generative AI model then reflects this again to generate a new design and present it to the user.

[0424] Prompt Sentence Examples

[0425] User design request: "A red dress with a heart pattern scattered all over it."

[0426] User sentiment: "Happy"

[0427] Design generation requirements:

[0428] 1. Red tones

[0429] 2. Scatter heart patterns all over the piece

[0430] 3. A design with warm colors and a fun atmosphere based on a sense of happiness

[0431] In this way, it is possible to provide more personalized and high-quality fashion designs by reflecting the user's emotions.

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

[0433] Step 1:

[0434] The device receives the user's input data. This is the process of the user entering their design requirements into an input form via a smartphone or head-mounted display. For example, a request might be "I want a red dress with a scattered heart pattern." This data is then sent from the device to the server.

[0435] Step 2:

[0436] The server analyzes the input data it receives and converts it into design elements. The input data is broken down into individual elements using a text analysis algorithm (such as natural language processing technology), and then analyzed. For example, the data is converted into design elements such as "red," "dress," and "heart pattern."

[0437] Step 3:

[0438] The device recognizes and collects the user's emotional data, using a camera and microphone to capture the user's facial expressions and tone of voice, and transmits this emotional data to a server in real time.

[0439] Step 4:

[0440] The server analyzes the emotion data. Using libraries such as TensorFlow and OpenCV, it analyzes the captured facial and voice data to identify the user's emotional state (e.g., happiness, surprise, sadness, etc.). The analysis result is an emotional state such as "happiness."

[0441] Step 5:

[0442] The server generates designs based on input data and emotion data. Using a generative inverse competitive network (GAN) or a transformer model, it generates designs based on the user's requests and emotion data. It also references the sewing factory's constraints and rules and adjusts them to meet these. The generated designs are compiled as design data.

[0443] Step 6:

[0444] The server sends the generated design data to the user's device, which then visually displays the design data to the user, who then confirms the generated design.

[0445] Step 7:

[0446] The user inputs specific requests for modifications to the design, such as "make the heart pattern bigger and add frills to the bottom of the dress." This data is then sent back to the server.

[0447] Step 8:

[0448] The server analyzes the modification request and emotion data and regenerates the design. A new design is generated based on the modification request and emotion data using the regeneration AI model. This process regenerates the modified design data.

[0449] Step 9:

[0450] The server sends the regenerated design data to the user's terminal, which again displays it to the user. This step is repeated until the user confirms the regenerated design and is finally satisfied.

[0451] Step 10:

[0452] The user finally decides on a design they are satisfied with. Once the user presses the "Confirm" button, the server saves the final design data. This data is then sent to the sewing factory as order data, including design details, material information, and production specifications.

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

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

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

[0456] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0469] The present invention relates to a system that allows users to design original fashion items based on their own design needs and then actually produce them in accordance with the restrictions of a sewing factory.

[0470] System Overview

[0471] The system receives design requests from users, converts them into design elements, and generates the design using a generative AI model. This design is presented visually to the user, who can input correction requests and regenerate the design. The finalized design data is sent to the sewing factory, where production begins.

[0472] Program processing

[0473] 1. Accepting user input

[0474] Users access the platform using a web browser and enter their design ideas and requirements into an input form, including the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs).

[0475] 2. Processing of input content

[0476] The terminal (user device) sends input to the server, which analyzes the received data and uses a text analysis algorithm to break down the user's request into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs).

[0477] 3. Design Generation Using Models

[0478] The server references the sewing factory's constraints and rules, and calls a generative AI model to generate a design based on the user's requests. The generative AI model uses technologies such as generative inverse competitive networks and transformer models. This model generates a design that conforms to the user's requests and constraints.

[0479] 4. Viewing the generated design

[0480] The server sends the generated design data to the user's device, which displays it on a web page, where the user can visually check the generated design.

[0481] 5. User Verification and Correction

[0482] The user can review the generated design and add correction requests if necessary, which are then sent back to the server, which analyzes them and generates the design again using the generative AI model.

[0483] 6. Finalize and save the design

[0484] Once the user is satisfied with the final design, they press the "Confirm" button. The server stores this design data and, if necessary, sends it to the sewing factory as order data. This data includes design details, material information, production specifications, etc.

[0485] Specific examples

[0486] For example, if a user requests a "blue hoodie with a zipper on the hood and ribbed cuffs," the process is as follows:

[0487] 1. A user accesses the design platform, enters their request, and submits it.

[0488] 2. The device sends the input data to the server.

[0489] 3. The server parses the data and breaks it down into design elements.

[0490] 4. The server references the sewing factory's constraints and generates the design using a generative AI model.

[0491] 5. The server sends the generated design data to the user's device.

[0492] 6. The device displays the design for the user to review.

[0493] 7. If the user enters a modification request, the data is sent to the server.

[0494] 8. The server analyzes the modification request and regenerates the design.

[0495] 9. Once the user has finalized the design to their satisfaction, the server saves the design data and sends it to the sewing factory as order data.

[0496] In this way, original fashion items based on the user's requests are efficiently generated and manufactured.

[0497] The processing flow will be explained below.

[0498] Step 1:

[0499] Users access the design platform using a web browser and enter their requirements into a design form, including color, shape, material, and specific design elements (e.g., a zipper on the hood, ribbed cuffs).

[0500] Step 2:

[0501] The device sends the input data to the server, which includes the design requests entered by the user.

[0502] Step 3:

[0503] The server parses the input data it receives, using a text analysis algorithm to break down the user's request into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs).

[0504] Step 4:

[0505] The server compares the parsed design elements with the constraints and rules of the sewing factory to ensure that the request meets the constraints, ensuring that the design is actually manufacturable.

[0506] Step 5:

[0507] The server calls a generative AI model, such as a generative inverse competitive network or a transformer model, to generate a fashion design based on the user's requests and constraints.

[0508] Step 6:

[0509] The server sends the generated design data to the user's device, which includes a visual representation of the design and detailed specifications.

[0510] Step 7:

[0511] The device displays the received design data on a web page, allowing the user to check the generated design.

[0512] Step 8:

[0513] The user checks the displayed design and inputs any corrections that are needed (e.g., "The zipper on the hood should be a little longer.") The correction request is then sent back to the server.

[0514] Step 9:

[0515] The server analyzes the modification request and calls the generative AI model again to regenerate the model reflecting the modifications.

[0516] Step 10:

[0517] The server transmits new design data generated based on the modification request to the user's terminal, which then displays it again.

[0518] Step 11:

[0519] The user confirms the final design that satisfies them and presses the "Confirm" button, which confirms the final design.

[0520] Step 12:

[0521] The server stores the finalized design data and, if necessary, sends it to the sewing factory as order data, which includes details of the design, material information, production specifications, etc.

[0522] The above is the specific process flow from user input to requesting the production of a fashion item.

[0523] Example 1

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

[0525] Conventional fashion design generation systems have difficulty efficiently integrating user requests with the constraints of sewing factories. It is also difficult to modify and check generated designs in real time, resulting in a poor user experience. Furthermore, the process of analyzing user design requests in detail and appropriately reflecting them in the generation AI model requires advanced technology, which increases the complexity of the system.

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

[0527] In this invention, the server includes means for receiving user input data, means for analyzing the received input data and converting it into design elements, means for referencing the sewing factory's constraints and rules to confirm whether the design satisfies the constraints, means for generating a fashion design based on the user's requests and constraints using a generative AI model, means for displaying the generated design data to the user and receiving revision requests, means for reanalyzing the user's revision requests and displaying the design regenerated by the generative AI model, means for saving the finalized design data and transmitting it to the sewing factory as order data as necessary, means for transmitting the received design data to the user's terminal using a web browser, means for saving the design elements in a database and retrieving the sewing factory's constraints from an internal database, and means for receiving user input in real time and waiting for the click of a send button. This allows for efficient integration of user and sewing factory requests and allows for real-time design revision and confirmation.

[0528] "Means for receiving user input data" refers to providing a function that allows users to enter design ideas and requests into an input form using a web browser.

[0529] The "means for analyzing received input data and converting it into design elements" means a means for analyzing input user requests using a text analysis algorithm and breaking them down into specific design elements.

[0530] "Means for referencing the restrictions and rules of the sewing factory and verifying that the design meets the restrictions" refers to retrieving restrictions such as available materials, colors, and sewing patterns at the sewing factory from an internal database and verifying that the generated design complies with these restrictions.

[0531] "Means for generating fashion designs based on user requests and constraints using a generative AI model" refers to the use of a generative AI model such as a generative inverse competitive network or a transformer model to automatically generate fashion designs that take into account user requests and the constraints of garment factories.

[0532] The "means for displaying the generated design data to the user and receiving requests for revisions" means sending the generated design data to the user's device, enabling the user to visually check the design on a web browser, and further enabling the user to receive requests for revisions.

[0533] "Means for re-analyzing the user's request for revisions and displaying a regenerated design using a generative AI model" refers to re-analyzing the user's request for revisions, generating a new design using a generative AI model, and displaying it to the user again.

[0534] "Means for saving finalized design data and transmitting it to a sewing factory as order data as needed" means enabling a user to save finalized design data in a database and transmit it to a sewing factory as order data as needed.

[0535] "Means for transmitting received design data to the user's terminal using a web browser" means transmitting the generated design data to the user's terminal via a web browser.

[0536] The "means for storing design elements in a database and retrieving sewing factory restrictions from an internal database" means storing the analyzed design elements in a database and retrieving sewing factory restrictions from an internal database.

[0537] "Means for receiving user input in real time and waiting for the send button to be clicked" means receiving the information the user is entering into the input form in real time and waiting for the send button to be clicked.

[0538] This invention relates to a system that allows users to design original fashion items based on their own design requests and then actually produce them in accordance with the constraints of a sewing factory. The system of the present invention has the function of receiving design requests from users, converting them into design elements, and generating a design using a generative AI model. This design is presented visually to the user, and the user can input correction requests to regenerate the design. The finalized design data is sent to the sewing factory, where production begins.

[0539] Specific Embodiments of the System

[0540] Hardware and Software Configuration

[0541] User: Accesses the system platform using a web browser. User devices include PCs and smartphones.

[0542] Terminal: A device that transmits data entered by a user to a server. Generally, this is a PC or smartphone.

[0543] Server: Equipped with a central processing unit (CPU), data analysis software, and generative AI models. Specific software used includes NLTK and spaCy (text analysis), and TensorFlow and PyTorch (generative AI models).

[0544] Generative AI models: Generative inverse competitive networks (GANs) and transformer models are used to generate designs based on user preferences and the constraints of the garment factory.

[0545] Processing Steps

[0546] 1. Accepting user input

[0547] A user logs in to the system's platform using a web browser and enters their desired item type (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs) into an input form.

[0548] The terminal receives the input data in real time and waits for the send button to be clicked.

[0549] 2. Processing of input content

[0550] The user clicks the submit button, and the terminal sends the input data to the server in XML or JSON format.

[0551] The server parses the received data and uses text analysis algorithms such as NLTK or spaCy to break down user requests into individual design elements.

[0552] 3. Design generation using generative AI models

[0553] The server retrieves the sewing factory's constraints from an internal database, including information such as material type, available colors, and sewing patterns.

[0554] The server calls the generative AI model and generates a design based on the user's requests and constraints.

[0555] Example prompt: "Generate a blue hoodie with a zipper on the hood and ribbed cuffs."

[0556] The server saves the generated design data in a certain format (e.g., SVG or PNG).

[0557] 4. Viewing the generated design

[0558] The server sends the generated design data to the user's device, which then displays the received design data on a web page. Users can visually check the design using HTML5 or JavaScript libraries (e.g., Canvas API, D3.js).

[0559] 5. User Verification and Correction

[0560] The user checks the displayed design and adds correction requests to the input form if necessary. They enter specific correction requests, such as "I want the hood size to be larger."

[0561] The terminal sends a modification request to the server, which analyzes it and displays the regenerated design again to the user.

[0562] 6. Finalize and save the design

[0563] When the user is satisfied with the final design, he / she clicks the "Confirm" button. The device sends the confirmation information to the server.

[0564] The server stores the finalized design data in a database and sends it to the sewing factory as order data. This order data includes design details, material information, and production specifications. The data may be sent using protocols such as API or FTP.

[0565] The server sends the user an order confirmation email.

[0566] Specific examples

[0567] For example, if a user requests a "red T-shirt with large pockets on the front and ribbed cuffs," the following steps are taken:

[0568] 1. The user accesses the platform, enters their request and submits it.

[0569] 2. The device sends the input information in JSON format to the server and clicks the send button.

[0570] 3. The server analyzes the data and breaks it down into design elements (e.g., "Color = red, Item = T-shirt, Detail 1 = large pocket on the front, Detail 2 = ribbed cuffs").

[0571] 4. The server retrieves the constraints of the sewing factory and inputs the prompt statement "A red T-shirt with a large pocket on the front and ribbed cuffs" into the generative AI model.

[0572] 5. The server saves the generated design data in PNG format and sends it to the user's device.

[0573] 6. The user reviews the design and submits a request for modification, such as "move the pocket to the left chest."

[0574] 7. The server analyzes the modification request, regenerates the design using the generative AI model, and sends it to the user's device.

[0575] 8. Once the user is satisfied with the design, they send it to the server as "confirmed," and the server saves the design data and sends it to the sewing factory as order data.

[0576] In this way, users can efficiently design original fashion items based on their own desires and even place an order.

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

[0578] Step 1: Receive user input

[0579] Users log in to the system platform using a web browser, for example, from a PC or smartphone.

[0580] The user inputs their design requirements (e.g., item type, color, and design elements) into an input form, such as "a blue hoodie with a zipper on the hood and ribbed cuffs."

[0581] The terminal receives this input data in real time and waits for the send button to be clicked.

[0582] Input: User's design request data (text format)

[0583] Output: Input data is retained until you click the submit button.

[0584] Step 2: Send and parse input

[0585] The user clicks the submit button.

[0586] The terminal sends input data to the server in XML or JSON format, which includes the requests entered by the user.

[0587] The server then analyzes the received data using a text analysis algorithm (such as NLTK or spaCy) to break down the request into individual design elements.

[0588] Specifically, it is converted into elements such as "color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs."

[0589] Input: User input data (JSON format)

[0590] Output: Decomposed design element data (internal data structure)

[0591] Step 3: Refer to the restrictions of the garment factory

[0592] The server retrieves the garment factory's constraints from an internal database, including material types, available colors, sewing patterns, etc.

[0593] Input: None (reference to internal database)

[0594] Output: Garment factory constraints data

[0595] Step 4: Generate a design using a generative AI model

[0596] The server calls a generative AI model (GAN or Transformer model) based on the acquired constraints of the sewing factory and the user's requests, and inputs a prompt statement.

[0597] Example prompt: "Generate a blue hoodie with a zipper on the hood and ribbed cuffs."

[0598] The server saves the generated design data in SVG or PNG format.

[0599] Input: User request data, sewing factory restriction data

[0600] Output: Generated design data (SVG or PNG format)

[0601] Step 5: View the generated design

[0602] The server transmits the generated design data to the user's terminal.

[0603] The device then displays the received design data on a web page, allowing users to visually check it using HTML5 and JavaScript libraries (e.g., Canvas API, D3.js).

[0604] Input: Generated design data (SVG or PNG format)

[0605] Output: Design displayed in browser

[0606] Step 6: Receive user confirmation and correction requests

[0607] The user checks the generated design and adds modifications to specific parts (e.g., changing the position of the pocket) in the input form.

[0608] The terminal sends a modification request to the server.

[0609] The server again analyzes the modification request and generates a new design using the generative AI model.

[0610] The server transmits the newly generated design data to the user terminal again and displays it again.

[0611] Input: User's correction request (text format)

[0612] Output: Regenerated design data (SVG or PNG format)

[0613] Step 7: Finalize and save your design

[0614] The user confirms that the design is satisfactory and clicks the "Confirm" button.

[0615] The terminal transmits the determination information to the server.

[0616] The server stores the confirmed design data in a database.

[0617] The server sends the design data to the sewing factory as order data as needed, using API and FTP protocols.

[0618] The server sends the user an order confirmation email.

[0619] Input: Finalized design data

[0620] Output: Save to database, send order data, confirmation email

[0621] Through the above processing steps, users can smoothly design original fashion items and complete their orders.

[0622] (Application example 1)

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

[0624] Previous fashion design systems were difficult to use or took a long time to reflect user requests. Furthermore, when users checked and revised their designs, they had problems receiving immediate feedback on the sewing factory's restrictions and feasibility. Furthermore, after the design was finalized, a separate purchasing process was required, resulting in poor user convenience.

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

[0626] In this invention, the server includes means for receiving user input data, means for analyzing the received input data and converting it into design elements, means for transmitting the analyzed design elements to the server via a communication network, means for referencing the sewing facility's constraints and rules and confirming whether the design satisfies the constraints, means for generating a fashion design based on the user's requests and constraints using a generative AI model, means for displaying the generated design data on the user's mobile device and receiving revision requests, means for re-analyzing the user's revision requests and displaying the design regenerated by the generative AI model on the user's mobile device, means for saving the finalized design data and transmitting it to the sewing facility as order data as needed, and means for purchasing items designed by the user. This significantly improves user convenience, enabling the quick and efficient creation and purchase of fashion items based on the user's own design preferences.

[0627] "User" refers to an individual who uses the system to design and ultimately purchase their own fashion items.

[0628] "Input data" refers to information such as the type, color, and design elements of a fashion item that a user provides to the system.

[0629] "Text analysis algorithm" refers to the technology that analyzes user input data and converts it into the necessary design elements.

[0630] "Server" refers to the central computing device that receives and analyzes user input data and performs design generation.

[0631] A "sewing facility" refers to a factory or work space where the fashion items designed by users are actually produced.

[0632] "Restrictions and Rules" refers to the technical and operational restrictions and regulations in the garment facility.

[0633] "Generative AI model" refers to artificial intelligence technology that generates optimal fashion designs based on user preferences and sewing facility constraints.

[0634] "Design Elements" refers to various specific design requirements (e.g., color, shape, details, etc.) provided by the user as input data.

[0635] "Modification Request" means a user's instruction for a change or adjustment to the generated design.

[0636] "Mobile Device" means the mobile device used by a User to access the System, input design elements, and review and modify generated designs.

[0637] "Order data" refers to data including production instructions and necessary information sent to a sewing facility based on the finalized design data.

[0638] "Purchase method" refers to the mechanisms and functions that allow users to order and complete purchases of their own designed fashion items online.

[0639] The system of the present invention provides a concrete means for users to customize, efficiently design and purchase their own fashion items.

[0640] Hardware and software used

[0641] Hardware:

[0642] Mobile devices such as smartphones and tablets

[0643] Central server (cloud-based or on-premise server)

[0644] software:

[0645] Application frameworks (React Native, Flutter)

[0646] Text analysis algorithms (spaCy, NLTK)

[0647] Generative AI models (GPT-4, DALL-E)

[0648] Communication protocol (HTTPS)

[0649] Database (MySQL, PostgreSQL)

[0650] Specific operation of the system

[0651] 1. Accept user input data

[0652] First, the user inputs their fashion item customization requirements using a dedicated application on their mobile device. For example, they can input a request for a "red T-shirt with a pocket on the front and stripes on the cuffs." The user's input data is sent to the server in text format.

[0653] 2. Converting to design elements

[0654] The server analyzes the received input data using a text analysis algorithm (e.g., spaCy or NLTK) and breaks it down into design elements such as:

[0655] Item: T-shirt

[0656] Color: Red

[0657] Detail 1: Front pocket

[0658] Detail 2: Stripes on the cuffs

[0659] 3. Design generation and confirmation

[0660] The server generates fashion designs using a generative AI model (e.g., GPT-4, DALL-E) based on the analyzed design elements and the constraints and rules of the sewing facility. The generated designs are then sent back to the user's mobile device, where they can be visually confirmed.

[0661] 4. Correction Requests and Regeneration

[0662] If a user requests modifications to the design, they re-enter their specific instructions (e.g., "make the pockets smaller") and send them to the server. The server analyzes the modifications and uses a generative AI model to generate a re-created design, allowing the user to make any number of modifications.

[0663] 5. Finalize the design and place an order

[0664] Once the user has finalized the design and is satisfied with it, they press the confirm button. The server stores this design data and sends it to the sewing facility as order data. This order data includes design details, material information, production specifications, etc.

[0665] 6. Purchase

[0666] Users can purchase the items they have designed directly within the application, and the purchasing process is intuitive and very convenient for users.

[0667] Specific examples

[0668] For example, if a user requests a "red T-shirt with a pocket on the front and stripes on the cuffs," the prompt might look like this:

[0669] User Request:

[0670] Item: T-shirt

[0671] Color: Red

[0672] Detail 1: Front pocket

[0673] Detail 2: Stripes on the cuffs

[0674] This prompt is then fed into the generative AI model, which then presents the resulting design to the user. If the user requests a modification (e.g., "Make the pockets smaller"), the new prompt becomes:

[0675] User Request:

[0676] Item: T-shirt

[0677] Color: Red

[0678] Detail 1: Small pocket on the front

[0679] Detail 2: Stripes on the cuffs

[0680] In this way, by creating a system in which designs are generated based on user requests, checked and revised, and finally ordered from a sewing facility, user convenience and satisfaction can be improved.

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

[0682] Step 1:

[0683] The user uses a dedicated application on their mobile device to input their requests for customizing fashion items. For example, they might input a request in text format such as "a red T-shirt with a pocket on the front and stripes on the cuffs." The input data is generated and sent from the device to the server.

[0684] Step 2:

[0685] The server analyzes the received input data using a text analysis algorithm (e.g., spaCy, NLTK). The input data, "a red T-shirt with a pocket on the front and stripes on the cuffs," is analyzed and converted into the following design elements:

[0686] Item: T-shirt

[0687] Color: Red

[0688] Detail 1: Front pocket

[0689] Detail 2: Stripes on the cuffs

[0690] After the design elements are extracted, a request is generated to reference the constraints and rules.

[0691] Step 3:

[0692] The server references the constraints and rules of the sewing facility to verify that the design meets the constraints. For example, it checks whether "stripes on the cuffs" are technically acceptable to the sewing factory and evaluates whether they meet certain constraints. Based on this information, it generates prompts for the generative AI model.

[0693] Step 4:

[0694] The server uses a generative AI model (e.g., GPT-4, DALL-E) to generate a fashion design based on the user's requirements and the constraints of the sewing facility. The server receives the prompt "User requirement: Item: T-shirt, Color: Red, Detail 1: Pocket on front, Detail 2: Stripes on cuffs" and retrieves the generated design image data. The generated design is then sent from the server to the user's mobile device.

[0695] Step 5:

[0696] The user checks the generated design on the mobile device. Depending on the displayed design, the user inputs a modification request. For example, the user inputs a modification request such as "make the pockets smaller" and sends it from the device to the server. The modification request is processed as new input data.

[0697] Step 6:

[0698] The server analyzes the modification request again (e.g., using spaCy or NLTK) and generates a regenerated design using the generative AI model. The modified prompt, "User wants: Item: T-shirt, Color: Red, Detail 1: Small pocket on the front, Detail 2: Stripes on the cuffs," is input to the model and new design image data is obtained. The regenerated design is then sent back to the user's mobile device.

[0699] Step 7:

[0700] The user confirms the final design and presses the confirm button. The server saves the final design data and generates order data, which includes design details, material information, production specifications, etc. The order data is sent to the sewing facility, and production begins.

[0701] Step 8:

[0702] Users can purchase the items they design directly within the application. The purchasing process is conducted through an intuitive interface, and the final output is a purchase confirmation data that is sent to the server and notified to 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 incorporates an emotion engine that recognizes the user's emotions, designs original fashion items based on the user's requests and emotions, and actually produces them in accordance with the restrictions of the sewing factory.

[0705] System Overview

[0706] The system receives design requests from users, recognizes their emotions using an emotion engine, converts them into design elements, and generates designs using a generative AI model. The generated designs are presented visually to the user, who can then regenerate the design by inputting correction requests and emotional feedback. The finalized design data is sent to the sewing factory, where production begins.

[0707] Program processing

[0708] 1. Accepting user input

[0709] Users access the design platform using a web browser and enter their design ideas and requirements into an input form, including the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs).

[0710] 2. Recognize user emotions

[0711] For emotion recognition, the device uses a webcam and microphone to capture the user's facial expressions and tone of voice, which are then sent to the emotion engine.

[0712] 3. Emotional Data Processing

[0713] The server uses an emotion engine to analyze the user's emotions from the captured data, for example, by using facial expression analysis algorithms or voice analysis algorithms to identify the user's emotional state (e.g., joy, sadness, surprise, etc.).

[0714] 4. Input and Emotional Data Processing

[0715] The server analyzes the user's input data and emotional data, and uses a text analysis algorithm to break down the user's requests into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs). The emotional data is used to adjust and optimize the design elements.

[0716] 5. Design Generation Using Models

[0717] The server references the sewing factory's constraints and rules, and calls a generative AI model to generate a design based on the user's requests and emotional data. Generative AI models use generative inverse competitive networks and transformer models, among other things. Emotional data is reflected in the color and design details.

[0718] 6. Viewing the generated design

[0719] The server sends the generated design data to the user's device, which displays it on a web page, where the user can visually check the generated design.

[0720] 7. User Verification and Correction

[0721] The user reviews the displayed design and enters specific changes based on their emotional state in the "Modification Request Form" (e.g., "The zipper on the hood should be a little longer"). The modification request and emotional data are then sent back to the server.

[0722] 8. Requesting corrections and reprocessing emotion data

[0723] The server analyzes the modification request and regenerates the design using the generative AI model while referring to the emotional data, thereby providing a design that reflects the user's emotional state.

[0724] 9. Finalize and save the design

[0725] Once the user is satisfied with the final design, they press the "Confirm" button. The server stores this design data and, if necessary, sends it to the sewing factory as order data. This data includes design details, material information, production specifications, etc.

[0726] Specific examples

[0727] For example, if a user requests a "blue hoodie with a zipper on the hood and ribbed cuffs," and the system recognizes that the user is expressing a feeling of satisfaction (happiness), it will adjust the design to reflect that emotion, using more detail and colors that emphasize the user's emotions. The design will then be presented to the user.

[0728] In this way, by reflecting the user's emotions, it becomes possible to design original fashion items that are more personal and satisfying.

[0729] The processing flow will be explained below.

[0730] Step 1:

[0731] Users access the design platform using a web browser and enter their design ideas and requirements into an input form, including the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs).

[0732] Step 2:

[0733] The device sends the input data to the server, which includes the design requests entered by the user.

[0734] Step 3:

[0735] For emotion recognition, the device uses a webcam and microphone to capture the user's facial expressions and tone of voice, which are then sent to the emotion engine in real time.

[0736] Step 4:

[0737] The server uses an emotion engine to analyze the user's emotions from the captured data, for example, by using facial expression analysis algorithms or voice analysis algorithms to identify the user's emotional state (e.g., joy, sadness, surprise, etc.).

[0738] Step 5:

[0739] The server analyzes the user's input data and emotional data, and uses a text analysis algorithm to break down the user's requests into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs). The emotional data is used to adjust and optimize the design elements.

[0740] Step 6:

[0741] The server references the sewing factory's constraints and rules, and calls a generative AI model to generate a design based on the user's requests and emotional data. Generative AI models use generative inverse competitive networks and transformer models, among other things. Emotional data is reflected in the color and design details.

[0742] Step 7:

[0743] The server sends the generated design data to the user's device, which includes a visual representation of the design and detailed specifications.

[0744] Step 8:

[0745] The device displays the received design data on a web page, where the user can visually check the generated design.

[0746] Step 9:

[0747] The user reviews the displayed design and enters specific changes based on their emotional state in the "Modification Request Form" (e.g., "The zipper on the hood should be a little longer"). The modification request and emotional data are then sent back to the server.

[0748] Step 10:

[0749] The server analyzes the modification request and regenerates the design using the generative AI model while referring to the emotional data, thereby providing a design that reflects the user's emotional state.

[0750] Step 11:

[0751] The server transmits new design data generated based on the modification request to the user's terminal, which then displays it again.

[0752] Step 12:

[0753] The user confirms the final design that satisfies them and presses the "Confirm" button, which confirms the final design.

[0754] Step 13:

[0755] The server stores the finalized design data and, if necessary, sends it to the sewing factory as order data, which includes details of the design, material information, production specifications, etc.

[0756] The above is the specific process flow for requesting the production of a fashion item, combining user input and emotion recognition.

[0757] Example 2

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

[0759] Conventional fashion design generation systems create designs based solely on the user's requests, making it difficult to reflect the user's emotions and latent needs. They also have problems with not being able to efficiently accommodate user requests for revisions, resulting in lower user satisfaction. Furthermore, it is difficult to generate designs that take into account the constraints of a sewing factory, often requiring numerous adjustments during the actual production process.

[0760] The specific processing by the specific processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes means for receiving user input data, means for collecting user emotional data using a webcam or microphone, means for analyzing the collected emotional data and identifying the user's emotional state, means for integrating the received input data and the analyzed emotional data and converting them into design elements, means for referring to the sewing factory's restrictions and rules and checking whether the design satisfies the restrictions, means for generating a fashion design based on the user's requests, emotional data, and restrictions using a generative AI model, means for displaying the generated design data to the user and receiving revision requests, means for re-analyzing the user's revision requests and emotional data and displaying the design regenerated by the generative AI model, and means for saving the finalized design data and, if necessary, transmitting it as order data to the sewing core industry. This enables personalized design generation that reflects the user's emotions, efficient revision support, and smooth production at the sewing factory.

[0761] "User input data" refers to requests and specification information regarding fashion items that users input through the design platform.

[0762] "Emotional data" refers to data on a user's facial expressions and voice collected using a webcam or microphone, and is used to analyze the user's emotional state.

[0763] An "emotion engine" is a system that includes algorithms and programs for analyzing collected emotional data and identifying the user's emotional state.

[0764] "Design elements" are information that refers to the characteristics and details of specific fashion items generated based on user input data and emotional data.

[0765] "Generative AI model" means an artificial intelligence model used to generate fashion designs based on user preferences, emotional data, and garment factory constraints, including a generative inverse competitive network or a transformer model.

[0766] "Sewing factory constraints" refers to information about factory equipment, technical constraints, and specifications that must be taken into consideration when actually producing fashion items.

[0767] "Order data" refers to data sent to a sewing factory that includes the finalized design data, necessary material information, production specifications, etc.

[0768] A "modification request" is a requirement that a user inputs in the form of specific instructions for changes to the generated design.

[0769] A "webcam" is an image input device used to collect facial expression data of a user.

[0770] A "microphone" is an audio input device used to collect data of a user's voice.

[0771] The present invention relates to a system for designing original fashion items using user emotional data and having the designs produced at a garment factory. This system involves a series of processes, starting with a user accessing a design platform and inputting their design requirements, followed by generating a design using an emotion recognition and generative AI model, and finally sending the finalized design to the garment factory.

[0772] System configuration

[0773] Hardware:

[0774] Terminal: The computer through which the user provides input.

[0775] Webcam: Image input device for collecting user facial expression data

[0776] Microphone: A voice input device for collecting data on the user's voice.

[0777] Server: A computer system that analyzes data and runs generative AI models.

[0778] software:

[0779] Design platform: a web application that provides the user interface

[0780] Emotion engine: Algorithms for analyzing user emotion data

[0781] Text analysis algorithms: Software that analyzes user input and converts it into design elements

[0782] Generative AI models: Artificial intelligence models for generating designs using generative inverse competitive networks (GANs) and transformer models.

[0783] Collecting user input and sentiment data

[0784] Users access the design platform and enter their design requirements into an input form. For example, they can enter specific requirements such as "a blue hoodie with a zipper on the hood and ribbed cuffs." At this time, the device's webcam and microphone are activated, and facial and voice data from the user is collected in real time.

[0785] Data analysis and design generation

[0786] The server uses an emotion engine to analyze the user's emotions from the collected facial and voice data. The analysis results indicate, for example, that the user is feeling "joy." The server then integrates the user's input data with the analyzed emotion data and converts it into design elements using a text analysis algorithm.

[0787] The server then calls up a generative AI model, taking into account the sewing factory's constraints, to generate a design based on the user's requests and emotional data. For example, the generative AI model might incorporate bright colors and detailed design elements to reflect the emotion of "joy."

[0788] View and modify the design

[0789] The generated design data is sent from the server to the user's device and displayed on a web page. The user can review the displayed design and input correction requests as needed. The correction requests and emotion data are sent back to the server, where the generative AI model regenerates the design, and the new design is provided to the user.

[0790] Final design confirmation and order placement

[0791] Once the user has confirmed the final design and clicked the "confirm" button, the server saves the design data. The saved design data is then sent to the sewing industry as order data. This data includes details of the design, material information, production specifications, etc.

[0792] Specific examples

[0793] For example, if a user requests a "blue hoodie with a zipper on the hood and ribbed cuffs," and the system recognizes that the user is expressing a feeling of satisfaction (happiness), it will adjust the design to reflect that emotion, using more detail and colors that emphasize the user's emotions. The design will then be presented to the user.

[0794] Prompt Sentence Examples

[0795] User input data:

[0796] Item Type: Hoodie

[0797] Color: Blue

[0798] Design elements:

[0799] Zipper on hood

[0800] Ribbed cuffs

[0801] User Emotion Data: Joy

[0802] Prompt statement:

[0803] "Based on the user's desire and emotional state, generate a design for a blue hoodie with a zippered hood and ribbed cuffs. The user is expressing the emotion of joy, so emphasize the design details and color."

[0804] By using these techniques, it is possible to design original fashion items that are personal and highly satisfying, reflecting the user's emotions.

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

[0806] Step 1: Receive user input

[0807] A user accesses the design platform using a web browser and inputs their design requirements. The input includes detailed information such as the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on the hood, ribbed cuffs). The input data is sent to the terminal through an input form. The terminal is responsible for sending this data to the server. Example of input data: "A blue hoodie with a zipper on the hood and ribbed cuffs."

[0808] Step 2: Collecting emotion data

[0809] The device activates the webcam and microphone to collect the user's facial and voice data. This data is captured in real time and sent to the emotion engine. The input data includes the user's facial images and voice recordings. The output data is the emotion data sent to the server.

[0810] Step 3: Analyze the emotion data

[0811] The server uses an emotion engine to analyze the collected facial expression data and voice data to identify the user's emotional state. It uses a facial expression analysis algorithm to analyze the facial expression data and a voice analysis algorithm to analyze the voice data. The resulting analysis results identify the user's emotional state (e.g., joy, sadness, surprise, etc.). The input data are facial expression and voice data, and the output data is the emotional state (e.g., the user is showing the emotion of "joy").

[0812] Step 4: Integrating and processing input and emotion data

[0813] The server combines the user's input data with the analyzed emotion data and converts it into design elements using a text analysis algorithm. The input data is broken down into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs), and the emotion data is used to adjust the design elements. The input data are the user's desires and emotion data, and the output data are the analyzed design elements.

[0814] Step 5: Generate a design using the model

[0815] The server references the sewing factory's restrictions and rules and generates designs using a generative AI model. The generative AI model uses a generative inverse competitive network (GAN) or a transformer model to generate optimal designs based on the user's requests and emotional data. The input data are design elements and emotional data, and the output data is the generated design.

[0816] Step 6: View the generated design

[0817] The server sends the generated design data to the user's device, and the device visually displays the design on a web page, where the user can check the generated design. The input data is the generated design data, and the output data is the design displayed to the user.

[0818] Step 7: Verify and modify users

[0819] The user checks the displayed design and enters specific changes in the "Modification Request Form." For example, they can enter specific instructions such as "I want the zipper on the hood to be a little longer." The modification request and emotion data are sent back to the server. The input data are the modification request and emotion data, and the output data is the updated input data.

[0820] Step 8: Request corrections and reprocess emotion data

[0821] The server analyzes the revision request and regenerates the design using the generative AI model while referring to the emotional data. This generates a revised design that reflects the user's emotional state. The input data are the revision request and emotional data, and the output data is the regenerated design.

[0822] Step 9: Finalize and save your design

[0823] The user finally confirms the design to their satisfaction and presses the "confirm" button. The server saves this design data and sends it to the sewing industry as order data. The order data includes design details, material information, production specifications, etc. The input data is the confirmed design data, and the output data is the saved design data and order data.

[0824] (Application example 2)

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

[0826] In recent years, the demand for original fashion items has increased, and users tend to want designs based on their own emotions. However, current systems cannot recognize users' emotions and reflect them in the design, so they cannot fully meet this demand. Furthermore, even if users request revisions, the design is not regenerated taking into account their emotional data, which results in a decrease in user satisfaction.

[0827] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving user input data, means for analyzing the received input data and converting it into design elements, means for recognizing and analyzing the user's emotional data, means for adjusting the design elements based on the emotional data, means for referencing the sewing factory's constraints and rules and confirming whether the design satisfies the constraints, means for generating a fashion design based on the user's requests, constraints, and emotional data using a generative AI model, means for displaying the generated design data to the user and receiving revision requests, means for reanalyzing the user's revision requests and emotional data and displaying the design regenerated by the generative AI model, and means for saving the finalized design data and, if necessary, transmitting it to the sewing factory as order data. This makes it possible to generate and modify designs that reflect the user's emotions.

[0828] "Means for receiving user input data" refers to means for providing an interface for users to input information such as design requests and ideas into the system.

[0829] "Means for analyzing received input data and converting it into design elements" refers to the algorithms or processes used to break down the input data received from the user into individual elements, analyze them, and convert them into design elements.

[0830] "Means for recognizing and analyzing user emotional data" refers to hardware and software for collecting and analyzing user emotions using technologies such as facial recognition and voice analysis.

[0831] "Means for adjusting design elements based on emotional data" refers to a mechanism for optimizing and adjusting design elements based on acquired emotional data, making it possible to fine-tune the design to reflect the user's emotions.

[0832] "Means of checking whether the design meets the constraints and rules of the garment factory" refers to a process or system for checking whether the generated design meets the technical and manufacturing constraints and rules of the garment factory.

[0833] "Means for generating fashion designs based on user requests, constraints, and emotional data using a generative AI model" refers to means for creating fashion designs based on user requests, constraints of the garment factory, and emotional data using a generative AI model such as a generative inverse competitive network or a transformer model.

[0834] "Means for displaying the generated design data to the user and receiving revision requests" refers to means for visually presenting the generated design data to the user and providing an interface for inputting revision requests from the user.

[0835] "Means for re-analyzing the user's revision requests and emotional data, and displaying a design re-generated by the generative AI model" refers to means for analyzing the user's revision requests and emotional data, re-generating a design using the generative AI model, and presenting it to the user.

[0836] "Means for saving the finalized design data and sending it to the sewing factory as order data as necessary" refers to the process for saving the design data that has been finalized by the user in the system and sending that data to the sewing factory as a production request.

[0837] The present invention is a system that recognizes a user's emotions and designs original fashion items based on those emotions, and specific embodiments thereof will be described below.

[0838] The system mainly consists of a terminal that receives user input data, a means for recognizing and analyzing emotional data, a means for generating designs using a generative AI model, and an interface for displaying and modifying the generated design data.

[0839] Configuration details

[0840] 1. Receiving and analyzing input data

[0841] A device (such as a smartphone or head-mounted display) receives design requests and ideas from users through an input form. The user's input data is sent to a server, which then analyzes the data using a text analysis algorithm (such as natural language processing technology) and converts it into design elements.

[0842] 2. Emotion Data Recognition and Analysis

[0843] The device's built-in camera and microphone are used to capture the user's facial expressions and tone of voice in real time. This emotional data is then analyzed using libraries such as TensorFlow and OpenCV. The server then determines the user's emotional state based on this emotional data.

[0844] 3. Design Generation

[0845] The server invokes a generative AI model using a generative inverse competitive network (GAN) or a transformer model based on the user's input data and emotional data. The generative AI model generates a design that reflects the user's wishes and emotional state. It also references the sewing factory's constraints and rules, adjusting the generated design to meet these conditions.

[0846] 4. View and modify the design

[0847] The generated design data is then sent back to the device and visually presented to the user. The user can then input any modifications they wish to make to the design into the system. The modifications are then analyzed again by the server, and the generative AI model generates a re-created design based on the emotion data.

[0848] 5. Finalize and save the design

[0849] Once the user is satisfied with the final design and presses the "confirm" button, the server saves the design data and sends it to the sewing factory as order data, including design details, material information, and production specifications.

[0850] Specific examples

[0851] For example, a user uses a smartphone to enter the following request:

[0852] "I want a red dress with a heart pattern scattered all over it."

[0853] If the user responds to this input with an emotion of "happiness," the system generates a warm color scheme and design that reflects that emotion. The user reviews the design and can enter the following if further adjustments are needed:

[0854] "Make the heart pattern bigger and add ruffles to the bottom of the dress."

[0855] The generative AI model then reflects this again to generate a new design and present it to the user.

[0856] Prompt Sentence Examples

[0857] User design request: "A red dress with a heart pattern scattered all over it."

[0858] User sentiment: "Happy"

[0859] Design generation requirements:

[0860] 1. Red tones

[0861] 2. Scatter heart patterns all over the piece

[0862] 3. A design with warm colors and a fun atmosphere based on a sense of happiness

[0863] In this way, it is possible to provide more personalized and high-quality fashion designs by reflecting the user's emotions.

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

[0865] Step 1:

[0866] The device receives the user's input data. This is the process of the user entering their design requirements into an input form via a smartphone or head-mounted display. For example, a request might be "I want a red dress with a scattered heart pattern." This data is then sent from the device to the server.

[0867] Step 2:

[0868] The server analyzes the input data it receives and converts it into design elements. The input data is broken down into individual elements using a text analysis algorithm (such as natural language processing technology), and then analyzed. For example, the data is converted into design elements such as "red," "dress," and "heart pattern."

[0869] Step 3:

[0870] The device recognizes and collects the user's emotional data, using a camera and microphone to capture the user's facial expressions and tone of voice, and transmits this emotional data to a server in real time.

[0871] Step 4:

[0872] The server analyzes the emotion data. Using libraries such as TensorFlow and OpenCV, it analyzes the captured facial and voice data to identify the user's emotional state (e.g., happiness, surprise, sadness, etc.). The analysis result is an emotional state such as "happiness."

[0873] Step 5:

[0874] The server generates designs based on input data and emotion data. Using a generative inverse competitive network (GAN) or a transformer model, it generates designs based on the user's requests and emotion data. It also references the sewing factory's constraints and rules and adjusts them to meet these. The generated designs are compiled as design data.

[0875] Step 6:

[0876] The server sends the generated design data to the user's device, which then visually displays the design data to the user, who then confirms the generated design.

[0877] Step 7:

[0878] The user inputs specific requests for modifications to the design, such as "make the heart pattern bigger and add frills to the bottom of the dress." This data is then sent back to the server.

[0879] Step 8:

[0880] The server analyzes the modification request and emotion data and regenerates the design. A new design is generated based on the modification request and emotion data using the regeneration AI model. This process regenerates the modified design data.

[0881] Step 9:

[0882] The server sends the regenerated design data to the user's terminal, which again displays it to the user. This step is repeated until the user confirms the regenerated design and is finally satisfied.

[0883] Step 10:

[0884] The user finally decides on a design they are satisfied with. Once the user presses the "Confirm" button, the server saves the final design data. This data is then sent to the sewing factory as order data, including design details, material information, and production specifications.

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

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

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

[0888] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0901] The present invention relates to a system that allows users to design original fashion items based on their own design needs and then actually produce them in accordance with the restrictions of a sewing factory.

[0902] System Overview

[0903] The system receives design requests from users, converts them into design elements, and generates the design using a generative AI model. This design is presented visually to the user, who can then input revision requests to generate the design again. The finalized design data is sent to the sewing factory, where production begins.

[0904] Program processing

[0905] 1. Accepting user input

[0906] Users access the platform using a web browser and enter their design ideas and requirements into an input form, including the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs).

[0907] 2. Processing of input content

[0908] The terminal (user device) sends input to the server, which analyzes the received data and uses a text analysis algorithm to break down the user's request into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs).

[0909] 3. Design Generation Using Models

[0910] The server references the sewing factory's constraints and rules, and calls a generative AI model to generate a design based on the user's requests. The generative AI model uses technologies such as generative inverse competitive networks and transformer models. This model generates a design that conforms to the user's requests and constraints.

[0911] 4. Viewing the generated design

[0912] The server sends the generated design data to the user's device, which displays it on a web page, where the user can visually check the generated design.

[0913] 5. User Verification and Correction

[0914] The user can review the generated design and add correction requests if necessary, which are then sent back to the server, which analyzes them and generates the design again using the generative AI model.

[0915] 6. Finalize and save the design

[0916] Once the user is satisfied with the final design, they press the "Confirm" button. The server stores this design data and, if necessary, sends it to the sewing factory as order data. This data includes design details, material information, production specifications, etc.

[0917] Specific examples

[0918] For example, if a user requests a "blue hoodie with a zipper on the hood and ribbed cuffs," the process is as follows:

[0919] 1. A user accesses the design platform, enters their request, and submits it.

[0920] 2. The device sends the input data to the server.

[0921] 3. The server parses the data and breaks it down into design elements.

[0922] 4. The server references the sewing factory's constraints and generates the design using a generative AI model.

[0923] 5. The server sends the generated design data to the user's device.

[0924] 6. The device displays the design for the user to review.

[0925] 7. If the user enters a modification request, the data is sent to the server.

[0926] 8. The server analyzes the modification request and regenerates the design.

[0927] 9. Once the user has finalized the design to their satisfaction, the server saves the design data and sends it to the sewing factory as order data.

[0928] In this way, original fashion items based on the user's requests are efficiently generated and manufactured.

[0929] The processing flow will be explained below.

[0930] Step 1:

[0931] Users access the design platform using a web browser and enter their requirements into a design form, including color, shape, material, and specific design elements (e.g., a zipper on the hood, ribbed cuffs).

[0932] Step 2:

[0933] The device sends the input data to the server, which includes the design requests entered by the user.

[0934] Step 3:

[0935] The server parses the input data it receives, using a text analysis algorithm to break down the user's request into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs).

[0936] Step 4:

[0937] The server compares the parsed design elements with the constraints and rules of the sewing factory to ensure that the request meets the constraints, ensuring that the design is actually manufacturable.

[0938] Step 5:

[0939] The server calls a generative AI model, such as a generative inverse competitive network or a transformer model, to generate a fashion design based on the user's requests and constraints.

[0940] Step 6:

[0941] The server sends the generated design data to the user's device, which includes a visual representation of the design and detailed specifications.

[0942] Step 7:

[0943] The device displays the received design data on a web page, allowing the user to check the generated design.

[0944] Step 8:

[0945] The user checks the displayed design and inputs any corrections that are needed (e.g., "The zipper on the hood should be a little longer.") The correction request is then sent back to the server.

[0946] Step 9:

[0947] The server analyzes the modification request and calls the generative AI model again to regenerate the model reflecting the modifications.

[0948] Step 10:

[0949] The server transmits new design data generated based on the modification request to the user's terminal, which then displays it again.

[0950] Step 11:

[0951] The user confirms the final design that satisfies them and presses the "Confirm" button, which confirms the final design.

[0952] Step 12:

[0953] The server stores the finalized design data and, if necessary, sends it to the sewing factory as order data, which includes details of the design, material information, production specifications, etc.

[0954] The above is the specific process flow from user input to requesting the production of a fashion item.

[0955] Example 1

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

[0957] Conventional fashion design generation systems have difficulty efficiently integrating user requests with the constraints of sewing factories. It is also difficult to modify and check generated designs in real time, resulting in a poor user experience. Furthermore, the process of analyzing user design requests in detail and appropriately reflecting them in the generation AI model requires advanced technology, which increases the complexity of the system.

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

[0959] In this invention, the server includes means for receiving user input data, means for analyzing the received input data and converting it into design elements, means for referencing the sewing factory's constraints and rules to confirm whether the design satisfies the constraints, means for generating a fashion design based on the user's requests and constraints using a generative AI model, means for displaying the generated design data to the user and receiving revision requests, means for reanalyzing the user's revision requests and displaying the design regenerated by the generative AI model, means for saving the finalized design data and transmitting it to the sewing factory as order data as necessary, means for transmitting the received design data to the user's terminal using a web browser, means for saving the design elements in a database and retrieving the sewing factory's constraints from an internal database, and means for receiving user input in real time and waiting for the click of a send button. This allows for efficient integration of user and sewing factory requests and allows for real-time design revision and confirmation.

[0960] "Means for receiving user input data" refers to providing a function that allows users to enter design ideas and requests into an input form using a web browser.

[0961] The "means for analyzing received input data and converting it into design elements" means a means for analyzing input user requests using a text analysis algorithm and breaking them down into specific design elements.

[0962] "Means for referencing the restrictions and rules of the sewing factory and verifying that the design meets the restrictions" refers to retrieving restrictions such as available materials, colors, and sewing patterns at the sewing factory from an internal database and verifying that the generated design complies with these restrictions.

[0963] "Means for generating fashion designs based on user requests and constraints using a generative AI model" refers to the use of a generative AI model such as a generative inverse competitive network or a transformer model to automatically generate fashion designs that take into account user requests and the constraints of garment factories.

[0964] The "means for displaying the generated design data to the user and receiving requests for revisions" means sending the generated design data to the user's device, enabling the user to visually check the design on a web browser, and further enabling the user to receive requests for revisions.

[0965] "Means for re-analyzing the user's request for revisions and displaying a regenerated design using a generative AI model" refers to re-analyzing the user's request for revisions, generating a new design using a generative AI model, and displaying it to the user again.

[0966] "Means for saving finalized design data and transmitting it to a sewing factory as order data as needed" means enabling a user to save finalized design data in a database and transmit it to a sewing factory as order data as needed.

[0967] "Means for transmitting received design data to the user's terminal using a web browser" means transmitting the generated design data to the user's terminal via a web browser.

[0968] The "means for storing design elements in a database and retrieving sewing factory restrictions from an internal database" means storing the analyzed design elements in a database and retrieving sewing factory restrictions from an internal database.

[0969] "Means for receiving user input in real time and waiting for the send button to be clicked" means receiving the information the user is entering into the input form in real time and waiting for the send button to be clicked.

[0970] This invention relates to a system that allows users to design original fashion items based on their own design requests and then actually produce them in accordance with the constraints of a sewing factory. The system of the present invention has the function of receiving design requests from users, converting them into design elements, and generating a design using a generative AI model. This design is presented visually to the user, and the user can input correction requests to regenerate the design. The finalized design data is sent to the sewing factory, where production begins.

[0971] Specific Embodiments of the System

[0972] Hardware and Software Configuration

[0973] User: Accesses the system platform using a web browser. User devices include PCs and smartphones.

[0974] Terminal: A device that transmits data entered by a user to a server. Generally, this is a PC or smartphone.

[0975] Server: Equipped with a central processing unit (CPU), data analysis software, and generative AI models. Specific software used includes NLTK and spaCy (text analysis), and TensorFlow and PyTorch (generative AI models).

[0976] Generative AI models: Generative inverse competitive networks (GANs) and transformer models are used to generate designs based on user preferences and the constraints of the garment factory.

[0977] Processing Steps

[0978] 1. Accepting user input

[0979] A user logs in to the system's platform using a web browser and enters their desired item type (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs) into an input form.

[0980] The terminal receives the input data in real time and waits for the send button to be clicked.

[0981] 2. Processing of input content

[0982] The user clicks the submit button, and the terminal sends the input data to the server in XML or JSON format.

[0983] The server parses the received data and uses text analysis algorithms such as NLTK or spaCy to break down user requests into individual design elements.

[0984] 3. Design generation using generative AI models

[0985] The server retrieves the sewing factory's constraints from an internal database, including information such as material type, available colors, and sewing patterns.

[0986] The server calls the generative AI model and generates a design based on the user's requests and constraints.

[0987] Example prompt: "Generate a blue hoodie with a zipper on the hood and ribbed cuffs."

[0988] The server saves the generated design data in a certain format (e.g., SVG or PNG).

[0989] 4. Viewing the generated design

[0990] The server sends the generated design data to the user's device, which then displays the received design data on a web page. Users can visually check the design using HTML5 or JavaScript libraries (e.g., Canvas API, D3.js).

[0991] 5. User Verification and Correction

[0992] The user checks the displayed design and adds correction requests to the input form if necessary. They enter specific correction requests, such as "I want the hood size to be larger."

[0993] The terminal sends a modification request to the server, which analyzes it and displays the regenerated design again to the user.

[0994] 6. Finalize and save the design

[0995] When the user is satisfied with the final design, he / she clicks the "Confirm" button. The device sends the confirmation information to the server.

[0996] The server stores the finalized design data in a database and sends it to the sewing factory as order data. This order data includes design details, material information, and production specifications. The data may be sent using protocols such as API or FTP.

[0997] The server sends the user an order confirmation email.

[0998] Specific examples

[0999] For example, if a user requests a "red T-shirt with large pockets on the front and ribbed cuffs," the following steps are taken:

[1000] 1. The user accesses the platform, enters their request and submits it.

[1001] 2. The device sends the input information in JSON format to the server and clicks the send button.

[1002] 3. The server analyzes the data and breaks it down into design elements (e.g., "Color = red, Item = T-shirt, Detail 1 = large pocket on the front, Detail 2 = ribbed cuffs").

[1003] 4. The server retrieves the constraints of the sewing factory and inputs the prompt statement "A red T-shirt with a large pocket on the front and ribbed cuffs" into the generative AI model.

[1004] 5. The server saves the generated design data in PNG format and sends it to the user's device.

[1005] 6. The user reviews the design and submits a request for modification, such as "move the pocket to the left chest."

[1006] 7. The server analyzes the modification request, regenerates the design using the generative AI model, and sends it to the user's device.

[1007] 8. Once the user is satisfied with the design, they send it to the server as "confirmed," and the server saves the design data and sends it to the sewing factory as order data.

[1008] In this way, users can efficiently design original fashion items based on their own desires and even place an order.

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

[1010] Step 1: Receive user input

[1011] Users log in to the system platform using a web browser, for example, from a PC or smartphone.

[1012] The user inputs their design requirements (e.g., item type, color, and design elements) into an input form, such as "a blue hoodie with a zipper on the hood and ribbed cuffs."

[1013] The terminal receives this input data in real time and waits for the send button to be clicked.

[1014] Input: User's design request data (text format)

[1015] Output: Input data is retained until you click the submit button.

[1016] Step 2: Send and parse input

[1017] The user clicks the submit button.

[1018] The terminal sends input data to the server in XML or JSON format, which includes the requests entered by the user.

[1019] The server then analyzes the received data using a text analysis algorithm (such as NLTK or spaCy) to break down the request into individual design elements.

[1020] Specifically, it is converted into elements such as "color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs."

[1021] Input: User input data (JSON format)

[1022] Output: Decomposed design element data (internal data structure)

[1023] Step 3: Refer to the restrictions of the garment factory

[1024] The server retrieves the garment factory's constraints from an internal database, including material types, available colors, sewing patterns, etc.

[1025] Input: None (reference to internal database)

[1026] Output: Garment factory constraints data

[1027] Step 4: Generate a design using a generative AI model

[1028] The server calls a generative AI model (GAN or Transformer model) based on the acquired constraints of the sewing factory and the user's requests, and inputs a prompt statement.

[1029] Example prompt: "Generate a blue hoodie with a zipper on the hood and ribbed cuffs."

[1030] The server saves the generated design data in SVG or PNG format.

[1031] Input: User request data, sewing factory restriction data

[1032] Output: Generated design data (SVG or PNG format)

[1033] Step 5: View the generated design

[1034] The server transmits the generated design data to the user's terminal.

[1035] The device then displays the received design data on a web page, allowing users to visually check it using HTML5 and JavaScript libraries (e.g., Canvas API, D3.js).

[1036] Input: Generated design data (SVG or PNG format)

[1037] Output: Design displayed in browser

[1038] Step 6: Receive user confirmation and correction requests

[1039] The user checks the generated design and adds modifications to specific parts (e.g., changing the position of the pocket) in the input form.

[1040] The terminal sends a modification request to the server.

[1041] The server again analyzes the modification request and generates a new design using the generative AI model.

[1042] The server transmits the newly generated design data to the user terminal again and displays it again.

[1043] Input: User's correction request (text format)

[1044] Output: Regenerated design data (SVG or PNG format)

[1045] Step 7: Finalize and save your design

[1046] The user confirms that the design is satisfactory and clicks the "Confirm" button.

[1047] The terminal transmits the determination information to the server.

[1048] The server stores the confirmed design data in a database.

[1049] The server sends the design data to the sewing factory as order data as needed, using API and FTP protocols.

[1050] The server sends the user an order confirmation email.

[1051] Input: Finalized design data

[1052] Output: Save to database, send order data, confirmation email

[1053] Through the above processing steps, users can smoothly design original fashion items and complete their orders.

[1054] (Application example 1)

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

[1056] Previous fashion design systems were difficult to use or took a long time to reflect user requests. Furthermore, when users checked and revised their designs, they had problems receiving immediate feedback on the sewing factory's restrictions and feasibility. Furthermore, after the design was finalized, a separate purchasing process was required, resulting in poor user convenience.

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

[1058] In this invention, the server includes means for receiving user input data, means for analyzing the received input data and converting it into design elements, means for transmitting the analyzed design elements to the server via a communication network, means for referencing the sewing facility's constraints and rules and confirming whether the design satisfies the constraints, means for generating a fashion design based on the user's requests and constraints using a generative AI model, means for displaying the generated design data on the user's mobile device and receiving revision requests, means for re-analyzing the user's revision requests and displaying the design regenerated by the generative AI model on the user's mobile device, means for saving the finalized design data and transmitting it to the sewing facility as order data as needed, and means for purchasing items designed by the user. This significantly improves user convenience, enabling the quick and efficient creation and purchase of fashion items based on the user's own design preferences.

[1059] "User" refers to an individual who uses the system to design and ultimately purchase their own fashion items.

[1060] "Input data" refers to information such as the type, color, and design elements of a fashion item that a user provides to the system.

[1061] "Text analysis algorithm" refers to the technology that analyzes user input data and converts it into the necessary design elements.

[1062] "Server" refers to the central computing device that receives and analyzes user input data and performs design generation.

[1063] A "sewing facility" refers to a factory or work space where the fashion items designed by users are actually produced.

[1064] "Restrictions and Rules" refers to the technical and operational restrictions and regulations in the garment facility.

[1065] "Generative AI model" refers to artificial intelligence technology that generates optimal fashion designs based on user preferences and sewing facility constraints.

[1066] "Design Elements" refers to various specific design requirements (e.g., color, shape, details, etc.) provided by the user as input data.

[1067] "Modification Request" means a user's instruction for a change or adjustment to the generated design.

[1068] "Mobile Device" means the mobile device used by a User to access the System, input design elements, and review and modify generated designs.

[1069] "Order data" refers to data including production instructions and necessary information sent to a sewing facility based on the finalized design data.

[1070] "Purchase method" refers to the mechanisms and functions that allow users to order and complete purchases of their own designed fashion items online.

[1071] The system of the present invention provides a concrete means for users to customize, efficiently design and purchase their own fashion items.

[1072] Hardware and software used

[1073] Hardware:

[1074] Mobile devices such as smartphones and tablets

[1075] Central server (cloud-based or on-premise server)

[1076] software:

[1077] Application frameworks (React Native, Flutter)

[1078] Text analysis algorithms (spaCy, NLTK)

[1079] Generative AI models (GPT-4, DALL-E)

[1080] Communication protocol (HTTPS)

[1081] Database (MySQL, PostgreSQL)

[1082] Specific operation of the system

[1083] 1. Accept user input data

[1084] First, the user inputs their fashion item customization requirements using a dedicated application on their mobile device. For example, they can input a request for a "red T-shirt with a pocket on the front and stripes on the cuffs." The user's input data is sent to the server in text format.

[1085] 2. Converting to design elements

[1086] The server analyzes the received input data using a text analysis algorithm (e.g., spaCy or NLTK) and breaks it down into design elements such as:

[1087] Item: T-shirt

[1088] Color: Red

[1089] Detail 1: Front pocket

[1090] Detail 2: Stripes on the cuffs

[1091] 3. Design generation and confirmation

[1092] The server generates fashion designs using a generative AI model (e.g., GPT-4, DALL-E) based on the analyzed design elements and the constraints and rules of the sewing facility. The generated designs are then sent back to the user's mobile device, where they can be visually confirmed.

[1093] 4. Correction Requests and Regeneration

[1094] If a user requests modifications to the design, they re-enter their specific instructions (e.g., "make the pockets smaller") and send them to the server. The server analyzes the modifications and uses a generative AI model to generate a re-created design, allowing the user to make any number of modifications.

[1095] 5. Finalize the design and place an order

[1096] Once the user has finalized the design and is satisfied with it, they press the confirm button. The server stores this design data and sends it to the sewing facility as order data. This order data includes design details, material information, production specifications, etc.

[1097] 6. Purchase

[1098] Users can purchase the items they have designed directly within the application, and the purchasing process is intuitive and very convenient for users.

[1099] Specific examples

[1100] For example, if a user requests a "red T-shirt with a pocket on the front and stripes on the cuffs," the prompt might look like this:

[1101] User Request:

[1102] Item: T-shirt

[1103] Color: Red

[1104] Detail 1: Front pocket

[1105] Detail 2: Stripes on the cuffs

[1106] This prompt is then fed into the generative AI model, which then presents the resulting design to the user. If the user requests a modification (e.g., "Make the pockets smaller"), the new prompt becomes:

[1107] User Request:

[1108] Item: T-shirt

[1109] Color: Red

[1110] Detail 1: Small pocket on the front

[1111] Detail 2: Stripes on the cuffs

[1112] In this way, by creating a system in which designs are generated based on user requests, checked and revised, and finally ordered from a sewing facility, user convenience and satisfaction can be improved.

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

[1114] Step 1:

[1115] The user uses a dedicated application on their mobile device to input their requests for customizing fashion items. For example, they might input a request in text format such as "a red T-shirt with a pocket on the front and stripes on the cuffs." The input data is generated and sent from the device to the server.

[1116] Step 2:

[1117] The server analyzes the received input data using a text analysis algorithm (e.g., spaCy, NLTK). The input data, "a red T-shirt with a pocket on the front and stripes on the cuffs," is analyzed and converted into the following design elements:

[1118] Item: T-shirt

[1119] Color: Red

[1120] Detail 1: Front pocket

[1121] Detail 2: Stripes on the cuffs

[1122] After the design elements are extracted, a request is generated to reference the constraints and rules.

[1123] Step 3:

[1124] The server references the constraints and rules of the sewing facility to verify that the design meets the constraints. For example, it checks whether "stripes on the cuffs" are technically acceptable to the sewing factory and evaluates whether they meet certain constraints. Based on this information, it generates prompts for the generative AI model.

[1125] Step 4:

[1126] The server uses a generative AI model (e.g., GPT-4, DALL-E) to generate a fashion design based on the user's requirements and the constraints of the sewing facility. The server receives the prompt "User requirement: Item: T-shirt, Color: Red, Detail 1: Pocket on front, Detail 2: Stripes on cuffs" and retrieves the generated design image data. The generated design is then sent from the server to the user's mobile device.

[1127] Step 5:

[1128] The user checks the generated design on the mobile device. Depending on the displayed design, the user inputs a modification request. For example, the user inputs a modification request such as "make the pockets smaller" and sends it from the device to the server. The modification request is processed as new input data.

[1129] Step 6:

[1130] The server analyzes the modification request again (e.g., using spaCy or NLTK) and generates a regenerated design using the generative AI model. The modified prompt, "User wants: Item: T-shirt, Color: Red, Detail 1: Small pocket on the front, Detail 2: Stripes on the cuffs," is input to the model and new design image data is obtained. The regenerated design is then sent back to the user's mobile device.

[1131] Step 7:

[1132] The user confirms the final design and presses the confirm button. The server saves the final design data and generates order data, which includes design details, material information, production specifications, etc. The order data is sent to the sewing facility, and production begins.

[1133] Step 8:

[1134] Users can purchase the items they design directly within the application. The purchasing process is conducted through an intuitive interface, and the final output is a purchase confirmation data that is sent to the server and notified to the user.

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

[1136] The present invention relates to a system that incorporates an emotion engine that recognizes the user's emotions, designs original fashion items based on the user's requests and emotions, and actually produces them in accordance with the restrictions of the sewing factory.

[1137] System Overview

[1138] The system receives design requests from users, recognizes their emotions using an emotion engine, converts them into design elements, and generates designs using a generative AI model. The generated designs are presented visually to the user, who can then regenerate the design by inputting correction requests and emotional feedback. The finalized design data is sent to the sewing factory, where production begins.

[1139] Program processing

[1140] 1. Accepting user input

[1141] Users access the design platform using a web browser and enter their design ideas and requirements into an input form, including the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs).

[1142] 2. Recognize user emotions

[1143] For emotion recognition, the device uses a webcam and microphone to capture the user's facial expressions and tone of voice, which are then sent to the emotion engine.

[1144] 3. Emotional Data Processing

[1145] The server uses an emotion engine to analyze the user's emotions from the captured data, for example, by using facial expression analysis algorithms or voice analysis algorithms to identify the user's emotional state (e.g., joy, sadness, surprise, etc.).

[1146] 4. Input and Emotional Data Processing

[1147] The server analyzes the user's input data and emotional data, and uses a text analysis algorithm to break down the user's requests into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs). The emotional data is used to adjust and optimize the design elements.

[1148] 5. Design Generation Using Models

[1149] The server references the sewing factory's constraints and rules, and calls a generative AI model to generate a design based on the user's requests and emotional data. Generative AI models use generative inverse competitive networks and transformer models, among other things. Emotional data is reflected in the color and design details.

[1150] 6. Viewing the generated design

[1151] The server sends the generated design data to the user's device, which displays it on a web page, where the user can visually check the generated design.

[1152] 7. User Verification and Correction

[1153] The user reviews the displayed design and enters specific changes based on their emotional state in the "Modification Request Form" (e.g., "The zipper on the hood should be a little longer"). The modification request and emotional data are then sent back to the server.

[1154] 8. Requesting corrections and reprocessing emotion data

[1155] The server analyzes the modification request and regenerates the design using the generative AI model while referring to the emotional data, thereby providing a design that reflects the user's emotional state.

[1156] 9. Finalize and save the design

[1157] Once the user is satisfied with the final design, they press the "Confirm" button. The server stores this design data and, if necessary, sends it to the sewing factory as order data. This data includes design details, material information, production specifications, etc.

[1158] Specific examples

[1159] For example, if a user requests a "blue hoodie with a zipper on the hood and ribbed cuffs," and the system recognizes that the user is expressing a feeling of satisfaction (happiness), it will adjust the design to reflect that emotion, using more detail and colors that emphasize the user's emotions. The design will then be presented to the user.

[1160] In this way, by reflecting the user's emotions, it becomes possible to design original fashion items that are more personal and satisfying.

[1161] The processing flow will be explained below.

[1162] Step 1:

[1163] Users access the design platform using a web browser and enter their design ideas and requirements into an input form, including the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs).

[1164] Step 2:

[1165] The device sends the input data to the server, which includes the design requests entered by the user.

[1166] Step 3:

[1167] For emotion recognition, the device uses a webcam and microphone to capture the user's facial expressions and tone of voice, which are then sent to the emotion engine in real time.

[1168] Step 4:

[1169] The server uses an emotion engine to analyze the user's emotions from the captured data, for example, by using facial expression analysis algorithms or voice analysis algorithms to identify the user's emotional state (e.g., joy, sadness, surprise, etc.).

[1170] Step 5:

[1171] The server analyzes the user's input data and emotional data, and uses a text analysis algorithm to break down the user's requests into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs). The emotional data is used to adjust and optimize the design elements.

[1172] Step 6:

[1173] The server references the sewing factory's constraints and rules, and calls a generative AI model to generate a design based on the user's requests and emotional data. Generative AI models use generative inverse competitive networks and transformer models, among other things. Emotional data is reflected in the color and design details.

[1174] Step 7:

[1175] The server sends the generated design data to the user's device, which includes a visual representation of the design and detailed specifications.

[1176] Step 8:

[1177] The device displays the received design data on a web page, where the user can visually check the generated design.

[1178] Step 9:

[1179] The user reviews the displayed design and enters specific changes based on their emotional state in the "Modification Request Form" (e.g., "The zipper on the hood should be a little longer"). The modification request and emotional data are then sent back to the server.

[1180] Step 10:

[1181] The server analyzes the modification request and regenerates the design using the generative AI model while referring to the emotional data, thereby providing a design that reflects the user's emotional state.

[1182] Step 11:

[1183] The server transmits new design data generated based on the modification request to the user's terminal, which then displays it again.

[1184] Step 12:

[1185] The user confirms the final design that satisfies them and presses the "Confirm" button, which confirms the final design.

[1186] Step 13:

[1187] The server stores the finalized design data and, if necessary, sends it to the sewing factory as order data, which includes details of the design, material information, production specifications, etc.

[1188] The above is the specific process flow for requesting the production of a fashion item, combining user input and emotion recognition.

[1189] Example 2

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

[1191] Conventional fashion design generation systems create designs based solely on the user's requests, making it difficult to reflect the user's emotions and latent needs. They also have problems with not being able to efficiently accommodate user requests for revisions, resulting in lower user satisfaction. Furthermore, it is difficult to generate designs that take into account the constraints of a sewing factory, often requiring numerous adjustments during the actual production process.

[1192] The specific processing by the specific processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes means for receiving user input data, means for collecting user emotional data using a webcam or microphone, means for analyzing the collected emotional data and identifying the user's emotional state, means for integrating the received input data and the analyzed emotional data and converting them into design elements, means for referring to the sewing factory's restrictions and rules and checking whether the design satisfies the restrictions, means for generating a fashion design based on the user's requests, emotional data, and restrictions using a generative AI model, means for displaying the generated design data to the user and receiving revision requests, means for re-analyzing the user's revision requests and emotional data and displaying the design regenerated by the generative AI model, and means for saving the finalized design data and, if necessary, transmitting it as order data to the sewing core industry. This enables personalized design generation that reflects the user's emotions, efficient revision support, and smooth production at the sewing factory.

[1193] "User input data" refers to requests and specification information regarding fashion items that users input through the design platform.

[1194] "Emotional data" refers to data on a user's facial expressions and voice collected using a webcam or microphone, and is used to analyze the user's emotional state.

[1195] An "emotion engine" is a system that includes algorithms and programs for analyzing collected emotional data and identifying the user's emotional state.

[1196] "Design elements" are information that refers to the characteristics and details of specific fashion items generated based on user input data and emotional data.

[1197] "Generative AI model" means an artificial intelligence model used to generate fashion designs based on user preferences, emotional data, and garment factory constraints, including a generative inverse competitive network or a transformer model.

[1198] "Sewing factory constraints" refers to information about factory equipment, technical constraints, and specifications that must be taken into consideration when actually producing fashion items.

[1199] "Order data" refers to data sent to a sewing factory that includes the finalized design data, necessary material information, production specifications, etc.

[1200] A "modification request" is a requirement that a user inputs in the form of specific instructions for changes to the generated design.

[1201] A "webcam" is an image input device used to collect facial expression data of a user.

[1202] A "microphone" is an audio input device used to collect data of a user's voice.

[1203] The present invention relates to a system for designing original fashion items using user emotional data and having the designs produced at a garment factory. This system involves a series of processes, starting with a user accessing a design platform and inputting their design requirements, followed by generating a design using an emotion recognition and generative AI model, and finally sending the finalized design to the garment factory.

[1204] System configuration

[1205] Hardware:

[1206] Terminal: The computer through which the user provides input.

[1207] Webcam: Image input device for collecting user facial expression data

[1208] Microphone: A voice input device for collecting data on the user's voice.

[1209] Server: A computer system that analyzes data and runs generative AI models.

[1210] software:

[1211] Design platform: a web application that provides the user interface

[1212] Emotion engine: Algorithms for analyzing user emotion data

[1213] Text analysis algorithms: Software that analyzes user input and converts it into design elements

[1214] Generative AI models: Artificial intelligence models for generating designs using generative inverse competitive networks (GANs) and transformer models.

[1215] Collecting user input and sentiment data

[1216] Users access the design platform and enter their design requirements into an input form. For example, they can enter specific requirements such as "a blue hoodie with a zipper on the hood and ribbed cuffs." At this time, the device's webcam and microphone are activated, and facial and voice data from the user is collected in real time.

[1217] Data analysis and design generation

[1218] The server uses an emotion engine to analyze the user's emotions from the collected facial and voice data. The analysis results indicate, for example, that the user is feeling "joy." The server then integrates the user's input data with the analyzed emotion data and converts it into design elements using a text analysis algorithm.

[1219] The server then calls up a generative AI model, taking into account the sewing factory's constraints, to generate a design based on the user's requests and emotional data. For example, the generative AI model might incorporate bright colors and detailed design elements to reflect the emotion of "joy."

[1220] View and modify the design

[1221] The generated design data is sent from the server to the user's device and displayed on a web page. The user can review the displayed design and input correction requests as needed. The correction requests and emotion data are sent back to the server, where the generative AI model regenerates the design, and the new design is provided to the user.

[1222] Final design confirmation and order placement

[1223] Once the user has confirmed the final design and clicked the "confirm" button, the server saves the design data. The saved design data is then sent to the sewing industry as order data. This data includes details of the design, material information, production specifications, etc.

[1224] Specific examples

[1225] For example, if a user requests a "blue hoodie with a zipper on the hood and ribbed cuffs," and the system recognizes that the user is expressing a feeling of satisfaction (happiness), it will adjust the design to reflect that emotion, using more detail and colors that emphasize the user's emotions. The design will then be presented to the user.

[1226] Prompt Sentence Examples

[1227] User input data:

[1228] Item Type: Hoodie

[1229] Color: Blue

[1230] Design elements:

[1231] Zipper on hood

[1232] Ribbed cuffs

[1233] User Emotion Data: Joy

[1234] Prompt statement:

[1235] "Based on the user's desire and emotional state, generate a design for a blue hoodie with a zippered hood and ribbed cuffs. The user is expressing the emotion of joy, so emphasize the design details and color."

[1236] By using these techniques, it is possible to design original fashion items that are personal and highly satisfying, reflecting the user's emotions.

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

[1238] Step 1: Receive user input

[1239] A user accesses the design platform using a web browser and inputs their design requirements. The input includes detailed information such as the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on the hood, ribbed cuffs). The input data is sent to the terminal through an input form. The terminal is responsible for sending this data to the server. Example of input data: "A blue hoodie with a zipper on the hood and ribbed cuffs."

[1240] Step 2: Collecting emotion data

[1241] The device activates the webcam and microphone to collect the user's facial and voice data. This data is captured in real time and sent to the emotion engine. The input data includes the user's facial images and voice recordings. The output data is the emotion data sent to the server.

[1242] Step 3: Analyze the emotion data

[1243] The server uses an emotion engine to analyze the collected facial expression data and voice data to identify the user's emotional state. It uses a facial expression analysis algorithm to analyze the facial expression data and a voice analysis algorithm to analyze the voice data. The resulting analysis results identify the user's emotional state (e.g., joy, sadness, surprise, etc.). The input data are facial expression and voice data, and the output data is the emotional state (e.g., the user is showing the emotion of "joy").

[1244] Step 4: Integrating and processing input and emotion data

[1245] The server combines the user's input data with the analyzed emotion data and converts it into design elements using a text analysis algorithm. The input data is broken down into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs), and the emotion data is used to adjust the design elements. The input data are the user's desires and emotion data, and the output data are the analyzed design elements.

[1246] Step 5: Generate a design using the model

[1247] The server references the sewing factory's restrictions and rules and generates designs using a generative AI model. The generative AI model uses a generative inverse competitive network (GAN) or a transformer model to generate optimal designs based on the user's requests and emotional data. The input data are design elements and emotional data, and the output data is the generated design.

[1248] Step 6: View the generated design

[1249] The server sends the generated design data to the user's device, and the device visually displays the design on a web page, where the user can check the generated design. The input data is the generated design data, and the output data is the design displayed to the user.

[1250] Step 7: Verify and modify users

[1251] The user checks the displayed design and enters specific changes in the "Modification Request Form." For example, they can enter specific instructions such as "I want the zipper on the hood to be a little longer." The modification request and emotion data are sent back to the server. The input data are the modification request and emotion data, and the output data is the updated input data.

[1252] Step 8: Request corrections and reprocess emotion data

[1253] The server analyzes the revision request and regenerates the design using the generative AI model while referring to the emotional data. This generates a revised design that reflects the user's emotional state. The input data are the revision request and emotional data, and the output data is the regenerated design.

[1254] Step 9: Finalize and save your design

[1255] The user finally confirms the design to their satisfaction and presses the "confirm" button. The server saves this design data and sends it to the sewing industry as order data. The order data includes design details, material information, production specifications, etc. The input data is the confirmed design data, and the output data is the saved design data and order data.

[1256] (Application example 2)

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

[1258] In recent years, the demand for original fashion items has increased, and users tend to want designs based on their own emotions. However, current systems cannot recognize users' emotions and reflect them in the design, so they cannot fully meet this demand. Furthermore, even if users request revisions, the design is not regenerated taking into account their emotional data, which results in a decrease in user satisfaction.

[1259] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving user input data, means for analyzing the received input data and converting it into design elements, means for recognizing and analyzing the user's emotional data, means for adjusting the design elements based on the emotional data, means for referencing the sewing factory's constraints and rules and confirming whether the design satisfies the constraints, means for generating a fashion design based on the user's requests, constraints, and emotional data using a generative AI model, means for displaying the generated design data to the user and receiving revision requests, means for reanalyzing the user's revision requests and emotional data and displaying the design regenerated by the generative AI model, and means for saving the finalized design data and, if necessary, transmitting it to the sewing factory as order data. This makes it possible to generate and modify designs that reflect the user's emotions.

[1260] "Means for receiving user input data" refers to means for providing an interface for users to input information such as design requests and ideas into the system.

[1261] "Means for analyzing received input data and converting it into design elements" refers to the algorithms or processes used to break down the input data received from the user into individual elements, analyze them, and convert them into design elements.

[1262] "Means for recognizing and analyzing user emotional data" refers to hardware and software for collecting and analyzing user emotions using technologies such as facial recognition and voice analysis.

[1263] "Means for adjusting design elements based on emotional data" refers to a mechanism for optimizing and adjusting design elements based on acquired emotional data, making it possible to fine-tune the design to reflect the user's emotions.

[1264] "Means of referencing the constraints and rules of the garment factory and verifying that the design meets the constraints" refers to a process or system for referencing the technical and manufacturing constraints and rules of the garment factory and verifying that the generated design meets these conditions.

[1265] "Means for using a generative AI model to generate fashion designs based on user requests, constraints, and emotional data" refers to means for using a generative AI model such as a generative inverse competitive network or a transformer model to create fashion designs based on user requests, constraints of a garment factory, and emotional data.

[1266] "Means for displaying the generated design data to the user and receiving revision requests" refers to means for visually presenting the generated design data to the user and providing an interface for inputting revision requests from the user.

[1267] "Means for re-analyzing the user's revision requests and emotional data, and displaying a design re-generated by the generative AI model" refers to means for analyzing the user's revision requests and emotional data, re-generating a design using the generative AI model, and presenting it to the user.

[1268] "Means for saving the finalized design data and sending it to the sewing factory as order data as necessary" refers to the process for saving the design data that has been finalized by the user in the system and sending that data to the sewing factory as a production request.

[1269] The present invention is a system that recognizes a user's emotions and designs original fashion items based on those emotions. Specific embodiments of the system will be described below.

[1270] The system mainly consists of a terminal that receives user input data, a means for recognizing and analyzing emotional data, a means for generating designs using a generative AI model, and an interface for displaying and modifying the generated design data.

[1271] Configuration details

[1272] 1. Receiving and analyzing input data

[1273] A device (such as a smartphone or head-mounted display) receives design requests and ideas from users through an input form. The user's input data is sent to a server, which then analyzes the data using a text analysis algorithm (such as natural language processing technology) and converts it into design elements.

[1274] 2. Emotion Data Recognition and Analysis

[1275] The device's built-in camera and microphone are used to capture the user's facial expressions and tone of voice in real time. This emotional data is then analyzed using libraries such as TensorFlow and OpenCV. The server then determines the user's emotional state based on this emotional data.

[1276] 3. Design Generation

[1277] The server invokes a generative AI model using a generative inverse competitive network (GAN) or a transformer model based on the user's input data and emotional data. The generative AI model generates a design that reflects the user's wishes and emotional state. It also references the sewing factory's constraints and rules, adjusting the generated design to meet these conditions.

[1278] 4. View and modify the design

[1279] The generated design data is then sent back to the device and visually presented to the user. The user can then input any modifications they wish to make to the design into the system. The modifications are then analyzed again by the server, and the generative AI model generates a re-created design based on the emotion data.

[1280] 5. Finalize and save the design

[1281] Once the user is satisfied with the final design and presses the "confirm" button, the server saves the design data and sends it to the sewing factory as order data, including design details, material information, and production specifications.

[1282] Specific examples

[1283] For example, a user uses a smartphone to enter the following request:

[1284] "I want a red dress with a heart pattern scattered all over it."

[1285] If the user responds to this input with an emotion of "happiness," the system generates a warm color scheme and design that reflects that emotion. The user reviews the design and can enter the following if further adjustments are needed:

[1286] "Make the heart pattern bigger and add ruffles to the bottom of the dress."

[1287] The generative AI model then reflects this again to generate a new design and present it to the user.

[1288] Prompt Sentence Examples

[1289] User design request: "A red dress with a heart pattern scattered all over it."

[1290] User sentiment: "Happy"

[1291] Design generation requirements:

[1292] 1. Red tones

[1293] 2. Scatter heart patterns all over the piece

[1294] 3. A design with warm colors and a fun atmosphere based on a sense of happiness

[1295] In this way, it is possible to provide more personalized and high-quality fashion designs by reflecting the user's emotions.

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

[1297] Step 1:

[1298] The device receives the user's input data. This is the process of the user entering their design requirements into an input form via a smartphone or head-mounted display. For example, a request might be "I want a red dress with a scattered heart pattern." This data is then sent from the device to the server.

[1299] Step 2:

[1300] The server analyzes the input data it receives and converts it into design elements. The input data is broken down into individual elements using a text analysis algorithm (such as natural language processing technology), and then analyzed. For example, the data is converted into design elements such as "red," "dress," and "heart pattern."

[1301] Step 3:

[1302] The device recognizes and collects the user's emotional data, using a camera and microphone to capture the user's facial expressions and tone of voice, and transmits this emotional data to a server in real time.

[1303] Step 4:

[1304] The server analyzes the emotion data. Using libraries such as TensorFlow and OpenCV, it analyzes the captured facial and voice data to identify the user's emotional state (e.g., happiness, surprise, sadness, etc.). The analysis result is an emotional state such as "happiness."

[1305] Step 5:

[1306] The server generates designs based on input data and emotion data. Using a generative inverse competitive network (GAN) or a transformer model, it generates designs based on the user's requests and emotion data. It also references the sewing factory's constraints and rules and adjusts them to meet these. The generated designs are compiled as design data.

[1307] Step 6:

[1308] The server sends the generated design data to the user's device, which then visually displays the design data to the user, who then confirms the generated design.

[1309] Step 7:

[1310] The user inputs specific requests for modifications to the design, such as "make the heart pattern bigger and add frills to the bottom of the dress." This data is then sent back to the server.

[1311] Step 8:

[1312] The server analyzes the modification request and emotion data and regenerates the design. A new design is generated based on the modification request and emotion data using the regeneration AI model. This process regenerates the modified design data.

[1313] Step 9:

[1314] The server sends the regenerated design data to the user's terminal, which again displays it to the user. This step is repeated until the user confirms the regenerated design and is finally satisfied.

[1315] Step 10:

[1316] The user finally decides on a design they are satisfied with. Once the user presses the "Confirm" button, the server saves the final design data. This data is then sent to the sewing factory as order data, including design details, material information, and production specifications.

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

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

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

[1320] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1334] The present invention relates to a system that allows users to design original fashion items based on their own design needs and then actually produce them in accordance with the restrictions of a sewing factory.

[1335] System Overview

[1336] The system receives design requests from users, converts them into design elements, and generates the design using a generative AI model. This design is presented visually to the user, who can then input revision requests to generate the design again. The finalized design data is sent to the sewing factory, where production begins.

[1337] Program processing

[1338] 1. Accepting user input

[1339] Users access the platform using a web browser and enter their design ideas and requirements into an input form, including the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs).

[1340] 2. Processing of input content

[1341] The terminal (user device) sends input to the server, which analyzes the received data and uses a text analysis algorithm to break down the user's request into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs).

[1342] 3. Design Generation Using Models

[1343] The server references the sewing factory's constraints and rules, and calls a generative AI model to generate a design based on the user's requests. The generative AI model uses technologies such as generative inverse competitive networks and transformer models. This model generates a design that conforms to the user's requests and constraints.

[1344] 4. Viewing the generated design

[1345] The server sends the generated design data to the user's device, which displays it on a web page, where the user can visually check the generated design.

[1346] 5. User Verification and Correction

[1347] The user can review the generated design and add correction requests if necessary, which are then sent back to the server, which analyzes them and generates the design again using the generative AI model.

[1348] 6. Finalize and save the design

[1349] Once the user is satisfied with the final design, they press the "Confirm" button. The server stores this design data and, if necessary, sends it to the sewing factory as order data. This data includes design details, material information, production specifications, etc.

[1350] Specific examples

[1351] For example, if a user requests a "blue hoodie with a zipper on the hood and ribbed cuffs," the process is as follows:

[1352] 1. A user accesses the design platform, enters their request, and submits it.

[1353] 2. The device sends the input data to the server.

[1354] 3. The server parses the data and breaks it down into design elements.

[1355] 4. The server references the sewing factory's constraints and generates the design using a generative AI model.

[1356] 5. The server sends the generated design data to the user's device.

[1357] 6. The device displays the design for the user to review.

[1358] 7. If the user enters a modification request, the data is sent to the server.

[1359] 8. The server analyzes the modification request and regenerates the design.

[1360] 9. Once the user has finalized the design to their satisfaction, the server saves the design data and sends it to the sewing factory as order data.

[1361] In this way, original fashion items based on the user's requests are efficiently generated and manufactured.

[1362] The processing flow will be explained below.

[1363] Step 1:

[1364] Users access the design platform using a web browser and enter their requirements into a design form, including color, shape, material, and specific design elements (e.g., a zipper on the hood, ribbed cuffs).

[1365] Step 2:

[1366] The device sends the input data to the server, which includes the design requests entered by the user.

[1367] Step 3:

[1368] The server parses the input data it receives, using a text analysis algorithm to break down the user's request into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs).

[1369] Step 4:

[1370] The server compares the parsed design elements with the constraints and rules of the sewing factory to ensure that the request meets the constraints, ensuring that the design is actually manufacturable.

[1371] Step 5:

[1372] The server calls a generative AI model, such as a generative inverse competitive network or a transformer model, to generate a fashion design based on the user's requests and constraints.

[1373] Step 6:

[1374] The server sends the generated design data to the user's device, which includes a visual representation of the design and detailed specifications.

[1375] Step 7:

[1376] The device displays the received design data on a web page, allowing the user to check the generated design.

[1377] Step 8:

[1378] The user checks the displayed design and inputs any corrections that are needed (e.g., "The zipper on the hood should be a little longer.") The correction request is then sent back to the server.

[1379] Step 9:

[1380] The server analyzes the modification request and calls the generative AI model again to regenerate the model reflecting the modifications.

[1381] Step 10:

[1382] The server transmits new design data generated based on the modification request to the user's terminal, which then displays it again.

[1383] Step 11:

[1384] The user confirms the final design that satisfies them and presses the "Confirm" button, which confirms the final design.

[1385] Step 12:

[1386] The server stores the finalized design data and, if necessary, sends it to the sewing factory as order data, which includes details of the design, material information, production specifications, etc.

[1387] The above is the specific process flow from user input to requesting the production of a fashion item.

[1388] Example 1

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

[1390] Conventional fashion design generation systems have difficulty efficiently integrating user requests with the constraints of sewing factories. It is also difficult to modify and check generated designs in real time, resulting in a poor user experience. Furthermore, the process of analyzing user design requests in detail and appropriately reflecting them in the generation AI model requires advanced technology, which increases the complexity of the system.

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

[1392] In this invention, the server includes means for receiving user input data, means for analyzing the received input data and converting it into design elements, means for referencing the sewing factory's constraints and rules to confirm whether the design satisfies the constraints, means for generating a fashion design based on the user's requests and constraints using a generative AI model, means for displaying the generated design data to the user and receiving revision requests, means for reanalyzing the user's revision requests and displaying the design regenerated by the generative AI model, means for saving the finalized design data and transmitting it to the sewing factory as order data as necessary, means for transmitting the received design data to the user's terminal using a web browser, means for saving the design elements in a database and retrieving the sewing factory's constraints from an internal database, and means for receiving user input in real time and waiting for the click of a send button. This allows for efficient integration of user and sewing factory requests and allows for real-time design revision and confirmation.

[1393] "Means for receiving user input data" refers to providing a function that allows users to enter design ideas and requests into an input form using a web browser.

[1394] The "means for analyzing received input data and converting it into design elements" means a means for analyzing input user requests using a text analysis algorithm and breaking them down into specific design elements.

[1395] "Means for referencing the restrictions and rules of the sewing factory and verifying that the design meets the restrictions" refers to retrieving restrictions such as available materials, colors, and sewing patterns at the sewing factory from an internal database and verifying that the generated design complies with these restrictions.

[1396] "Means for generating fashion designs based on user requests and constraints using a generative AI model" refers to the use of a generative AI model such as a generative inverse competitive network or a transformer model to automatically generate fashion designs that take into account user requests and the constraints of garment factories.

[1397] The "means for displaying the generated design data to the user and receiving requests for revisions" means sending the generated design data to the user's device, enabling the user to visually check the design on a web browser, and further enabling the user to receive requests for revisions.

[1398] "Means for re-analyzing the user's request for revisions and displaying a regenerated design using a generative AI model" refers to re-analyzing the user's request for revisions, generating a new design using a generative AI model, and displaying it to the user again.

[1399] "Means for saving finalized design data and transmitting it to a sewing factory as order data as needed" means enabling a user to save finalized design data in a database and transmit it to a sewing factory as order data as needed.

[1400] "Means for transmitting received design data to the user's terminal using a web browser" means transmitting the generated design data to the user's terminal via a web browser.

[1401] The "means for storing design elements in a database and retrieving sewing factory restrictions from an internal database" means storing the analyzed design elements in a database and retrieving sewing factory restrictions from an internal database.

[1402] "Means for receiving user input in real time and waiting for the send button to be clicked" means receiving the information the user is entering into the input form in real time and waiting for the send button to be clicked.

[1403] This invention relates to a system that allows users to design original fashion items based on their own design requests and then actually produce them in accordance with the constraints of a sewing factory. The system of the present invention has the function of receiving design requests from users, converting them into design elements, and generating a design using a generative AI model. This design is presented visually to the user, and the user can input correction requests to regenerate the design. The finalized design data is sent to the sewing factory, where production begins.

[1404] Specific Embodiments of the System

[1405] Hardware and Software Configuration

[1406] User: Accesses the system platform using a web browser. User devices include PCs and smartphones.

[1407] Terminal: A device that transmits data entered by a user to a server. Generally, this is a PC or smartphone.

[1408] Server: Equipped with a central processing unit (CPU), data analysis software, and generative AI models. Specific software used includes NLTK and spaCy (text analysis), and TensorFlow and PyTorch (generative AI models).

[1409] Generative AI models: Generative inverse competitive networks (GANs) and transformer models are used to generate designs based on user preferences and the constraints of the garment factory.

[1410] Processing Steps

[1411] 1. Accepting user input

[1412] A user logs in to the system's platform using a web browser and enters their desired item type (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs) into an input form.

[1413] The terminal receives the input data in real time and waits for the send button to be clicked.

[1414] 2. Processing of input content

[1415] The user clicks the submit button, and the terminal sends the input data to the server in XML or JSON format.

[1416] The server parses the received data and uses text analysis algorithms such as NLTK or spaCy to break down user requests into individual design elements.

[1417] 3. Design generation using generative AI models

[1418] The server retrieves the sewing factory's constraints from an internal database, including information such as material type, available colors, and sewing patterns.

[1419] The server calls the generative AI model and generates a design based on the user's requests and constraints.

[1420] Example prompt: "Generate a blue hoodie with a zipper on the hood and ribbed cuffs."

[1421] The server saves the generated design data in a certain format (e.g., SVG or PNG).

[1422] 4. Viewing the generated design

[1423] The server sends the generated design data to the user's device, which then displays the received design data on a web page. Users can visually check the design using HTML5 or JavaScript libraries (e.g., Canvas API, D3.js).

[1424] 5. User Verification and Correction

[1425] The user checks the displayed design and adds correction requests to the input form if necessary. They enter specific correction requests, such as "I want the hood size to be larger."

[1426] The terminal sends a modification request to the server, which analyzes it and displays the regenerated design again to the user.

[1427] 6. Finalize and save the design

[1428] When the user is satisfied with the final design, he / she clicks the "Confirm" button. The device sends the confirmation information to the server.

[1429] The server stores the finalized design data in a database and sends it to the sewing factory as order data. This order data includes design details, material information, and production specifications. The data may be sent using protocols such as API or FTP.

[1430] The server sends the user an order confirmation email.

[1431] Specific examples

[1432] For example, if a user requests a "red T-shirt with large pockets on the front and ribbed cuffs," the following steps are taken:

[1433] 1. The user accesses the platform, enters their request and submits it.

[1434] 2. The device sends the input information in JSON format to the server and clicks the send button.

[1435] 3. The server analyzes the data and breaks it down into design elements (e.g., "Color = red, Item = T-shirt, Detail 1 = large pocket on the front, Detail 2 = ribbed cuffs").

[1436] 4. The server retrieves the constraints of the sewing factory and inputs the prompt statement "A red T-shirt with a large pocket on the front and ribbed cuffs" into the generative AI model.

[1437] 5. The server saves the generated design data in PNG format and sends it to the user's device.

[1438] 6. The user reviews the design and submits a request for modification, such as "move the pocket to the left chest."

[1439] 7. The server analyzes the modification request, regenerates the design using the generative AI model, and sends it to the user's device.

[1440] 8. Once the user is satisfied with the design, they send it to the server as "confirmed," and the server saves the design data and sends it to the sewing factory as order data.

[1441] In this way, users can efficiently design original fashion items based on their own desires and even place an order.

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

[1443] Step 1: Receive user input

[1444] Users log in to the system platform using a web browser, for example, from a PC or smartphone.

[1445] The user inputs their design requirements (e.g., item type, color, and design elements) into an input form, such as "a blue hoodie with a zipper on the hood and ribbed cuffs."

[1446] The terminal receives this input data in real time and waits for the send button to be clicked.

[1447] Input: User's design request data (text format)

[1448] Output: Input data is retained until you click the submit button.

[1449] Step 2: Send and parse input

[1450] The user clicks the submit button.

[1451] The terminal sends input data to the server in XML or JSON format, which includes the requests entered by the user.

[1452] The server then analyzes the received data using a text analysis algorithm (such as NLTK or spaCy) to break down the request into individual design elements.

[1453] Specifically, it is converted into elements such as "color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs."

[1454] Input: User input data (JSON format)

[1455] Output: Decomposed design element data (internal data structure)

[1456] Step 3: Refer to the restrictions of the garment factory

[1457] The server retrieves the garment factory's constraints from an internal database, including material types, available colors, sewing patterns, etc.

[1458] Input: None (reference to internal database)

[1459] Output: Garment factory constraints data

[1460] Step 4: Generate a design using a generative AI model

[1461] The server calls a generative AI model (GAN or Transformer model) based on the acquired constraints of the sewing factory and the user's requests, and inputs a prompt statement.

[1462] Example prompt: "Generate a blue hoodie with a zipper on the hood and ribbed cuffs."

[1463] The server saves the generated design data in SVG or PNG format.

[1464] Input: User request data, sewing factory restriction data

[1465] Output: Generated design data (SVG or PNG format)

[1466] Step 5: View the generated design

[1467] The server transmits the generated design data to the user's terminal.

[1468] The device then displays the received design data on a web page, allowing users to visually check it using HTML5 and JavaScript libraries (e.g., Canvas API, D3.js).

[1469] Input: Generated design data (SVG or PNG format)

[1470] Output: Design displayed in browser

[1471] Step 6: Receive user confirmation and correction requests

[1472] The user checks the generated design and adds modifications to specific parts (e.g., changing the position of the pocket) in the input form.

[1473] The terminal sends a modification request to the server.

[1474] The server again analyzes the modification request and generates a new design using the generative AI model.

[1475] The server transmits the newly generated design data to the user terminal again and displays it again.

[1476] Input: User's correction request (text format)

[1477] Output: Regenerated design data (SVG or PNG format)

[1478] Step 7: Finalize and save your design

[1479] The user confirms that the design is satisfactory and clicks the "Confirm" button.

[1480] The terminal transmits the determination information to the server.

[1481] The server stores the confirmed design data in a database.

[1482] The server sends the design data to the sewing factory as order data as needed, using API and FTP protocols.

[1483] The server sends the user an order confirmation email.

[1484] Input: Finalized design data

[1485] Output: Save to database, send order data, confirmation email

[1486] Through the above processing steps, users can smoothly design original fashion items and complete their orders.

[1487] (Application example 1)

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

[1489] Previous fashion design systems were difficult to use or took a long time to reflect user requests. Furthermore, when users checked and revised their designs, they had problems receiving immediate feedback on the sewing factory's restrictions and feasibility. Furthermore, after the design was finalized, a separate purchasing process was required, resulting in poor user convenience.

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

[1491] In this invention, the server includes means for receiving user input data, means for analyzing the received input data and converting it into design elements, means for transmitting the analyzed design elements to the server via a communication network, means for referencing the sewing facility's constraints and rules and confirming whether the design satisfies the constraints, means for generating a fashion design based on the user's requests and constraints using a generative AI model, means for displaying the generated design data on the user's mobile device and receiving revision requests, means for re-analyzing the user's revision requests and displaying the design regenerated by the generative AI model on the user's mobile device, means for saving the finalized design data and transmitting it to the sewing facility as order data as needed, and means for purchasing items designed by the user. This significantly improves user convenience, enabling the quick and efficient creation and purchase of fashion items based on the user's own design preferences.

[1492] "User" refers to an individual who uses the system to design and ultimately purchase their own fashion items.

[1493] "Input data" refers to information such as the type, color, and design elements of a fashion item that a user provides to the system.

[1494] "Text analysis algorithm" refers to the technology that analyzes user input data and converts it into the necessary design elements.

[1495] "Server" refers to the central computing device that receives and analyzes user input data and performs design generation.

[1496] A "sewing facility" refers to a factory or work space where the fashion items designed by users are actually produced.

[1497] "Restrictions and Rules" refers to the technical and operational restrictions and regulations in the garment facility.

[1498] "Generative AI model" refers to artificial intelligence technology that generates optimal fashion designs based on user preferences and sewing facility constraints.

[1499] "Design Elements" refers to various specific design requirements (e.g., color, shape, details, etc.) provided by the user as input data.

[1500] "Modification Request" means a user's instruction for a change or adjustment to the generated design.

[1501] "Mobile Device" means the mobile device used by a User to access the System, input design elements, and review and modify generated designs.

[1502] "Order data" refers to data including production instructions and necessary information sent to a sewing facility based on the finalized design data.

[1503] "Purchase method" refers to the mechanisms and functions that allow users to order and complete purchases of their own designed fashion items online.

[1504] The system of the present invention provides a concrete means for users to customize, efficiently design and purchase their own fashion items.

[1505] Hardware and software used

[1506] Hardware:

[1507] Mobile devices such as smartphones and tablets

[1508] Central server (cloud-based or on-premise server)

[1509] software:

[1510] Application frameworks (React Native, Flutter)

[1511] Text analysis algorithms (spaCy, NLTK)

[1512] Generative AI models (GPT-4, DALL-E)

[1513] Communication protocol (HTTPS)

[1514] Database (MySQL, PostgreSQL)

[1515] Specific operation of the system

[1516] 1. Accept user input data

[1517] First, the user inputs their fashion item customization requirements using a dedicated application on their mobile device. For example, they can input a request for a "red T-shirt with a pocket on the front and stripes on the cuffs." The user's input data is sent to the server in text format.

[1518] 2. Converting to design elements

[1519] The server analyzes the received input data using a text analysis algorithm (e.g., spaCy or NLTK) and breaks it down into design elements such as:

[1520] Item: T-shirt

[1521] Color: Red

[1522] Detail 1: Front pocket

[1523] Detail 2: Stripes on the cuffs

[1524] 3. Design generation and confirmation

[1525] The server generates fashion designs using a generative AI model (e.g., GPT-4, DALL-E) based on the analyzed design elements and the constraints and rules of the sewing facility. The generated designs are then sent back to the user's mobile device, where they can be visually confirmed.

[1526] 4. Correction Requests and Regeneration

[1527] If a user requests modifications to the design, they re-enter their specific instructions (e.g., "make the pockets smaller") and send them to the server. The server analyzes the modifications and uses a generative AI model to generate a re-created design, allowing the user to make any number of modifications.

[1528] 5. Finalize the design and place an order

[1529] Once the user has finalized the design and is satisfied with it, they press the confirm button. The server stores this design data and sends it to the sewing facility as order data. This order data includes design details, material information, production specifications, etc.

[1530] 6. Purchase

[1531] Users can purchase the items they have designed directly within the application, and the purchasing process is intuitive and very convenient for users.

[1532] Specific examples

[1533] For example, if a user requests a "red T-shirt with a pocket on the front and stripes on the cuffs," the prompt might look like this:

[1534] User Request:

[1535] Item: T-shirt

[1536] Color: Red

[1537] Detail 1: Front pocket

[1538] Detail 2: Stripes on the cuffs

[1539] This prompt is then fed into the generative AI model, which then presents the resulting design to the user. If the user requests a modification (e.g., "Make the pockets smaller"), the new prompt becomes:

[1540] User Request:

[1541] Item: T-shirt

[1542] Color: Red

[1543] Detail 1: Small pocket on the front

[1544] Detail 2: Stripes on the cuffs

[1545] In this way, by creating a system in which designs are generated based on user requests, checked and revised, and finally ordered from a sewing facility, user convenience and satisfaction can be improved.

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

[1547] Step 1:

[1548] The user uses a dedicated application on their mobile device to input their requests for customizing fashion items. For example, they might input a request in text format such as "a red T-shirt with a pocket on the front and stripes on the cuffs." The input data is generated and sent from the device to the server.

[1549] Step 2:

[1550] The server analyzes the received input data using a text analysis algorithm (e.g., spaCy, NLTK). The input data, "a red T-shirt with a pocket on the front and stripes on the cuffs," is analyzed and converted into the following design elements:

[1551] Item: T-shirt

[1552] Color: Red

[1553] Detail 1: Front pocket

[1554] Detail 2: Stripes on the cuffs

[1555] After the design elements are extracted, a request is generated to reference the constraints and rules.

[1556] Step 3:

[1557] The server references the constraints and rules of the sewing facility to verify that the design meets the constraints. For example, it checks whether "stripes on the cuffs" are technically acceptable to the sewing factory and evaluates whether they meet certain constraints. Based on this information, it generates prompts for the generative AI model.

[1558] Step 4:

[1559] The server uses a generative AI model (e.g., GPT-4, DALL-E) to generate a fashion design based on the user's requirements and the constraints of the sewing facility. The server receives the prompt "User requirement: Item: T-shirt, Color: Red, Detail 1: Pocket on front, Detail 2: Stripes on cuffs" and retrieves the generated design image data. The generated design is then sent from the server to the user's mobile device.

[1560] Step 5:

[1561] The user checks the generated design on the mobile device. Depending on the displayed design, the user inputs a modification request. For example, the user inputs a modification request such as "make the pockets smaller" and sends it from the device to the server. The modification request is processed as new input data.

[1562] Step 6:

[1563] The server analyzes the modification request again (e.g., using spaCy or NLTK) and generates a regenerated design using the generative AI model. The modified prompt, "User wants: Item: T-shirt, Color: Red, Detail 1: Small pocket on the front, Detail 2: Stripes on the cuffs," is input to the model and new design image data is obtained. The regenerated design is then sent back to the user's mobile device.

[1564] Step 7:

[1565] The user confirms the final design and presses the confirm button. The server saves the final design data and generates order data, which includes design details, material information, production specifications, etc. The order data is sent to the sewing facility, and production begins.

[1566] Step 8:

[1567] Users can purchase the items they design directly within the application. The purchasing process is conducted through an intuitive interface, and the final output is a purchase confirmation data that is sent to the server and notified to the user.

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

[1569] The present invention relates to a system that incorporates an emotion engine that recognizes the user's emotions, designs original fashion items based on the user's requests and emotions, and actually produces them in accordance with the restrictions of the sewing factory.

[1570] System Overview

[1571] The system receives design requests from users, recognizes their emotions using an emotion engine, converts them into design elements, and generates designs using a generative AI model. The generated designs are presented visually to the user, who can then regenerate the design by inputting correction requests and emotional feedback. The finalized design data is sent to the sewing factory, where production begins.

[1572] Program processing

[1573] 1. Accepting user input

[1574] Users access the design platform using a web browser and enter their design ideas and requirements into an input form, including the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs).

[1575] 2. Recognize user emotions

[1576] For emotion recognition, the device uses a webcam and microphone to capture the user's facial expressions and tone of voice, which are then sent to the emotion engine.

[1577] 3. Emotional Data Processing

[1578] The server uses an emotion engine to analyze the user's emotions from the captured data, for example, by using facial expression analysis algorithms or voice analysis algorithms to identify the user's emotional state (e.g., joy, sadness, surprise, etc.).

[1579] 4. Input and Emotional Data Processing

[1580] The server analyzes the user's input data and emotional data, and uses a text analysis algorithm to break down the user's requests into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs). The emotional data is used to adjust and optimize the design elements.

[1581] 5. Design Generation Using Models

[1582] The server references the sewing factory's constraints and rules, and calls a generative AI model to generate a design based on the user's requests and emotional data. Generative AI models use generative inverse competitive networks and transformer models, among other things. Emotional data is reflected in the color and design details.

[1583] 6. Viewing the generated design

[1584] The server sends the generated design data to the user's device, which displays it on a web page, where the user can visually check the generated design.

[1585] 7. User Verification and Correction

[1586] The user reviews the displayed design and enters specific changes based on their emotional state in the "Modification Request Form" (e.g., "The zipper on the hood should be a little longer"). The modification request and emotional data are then sent back to the server.

[1587] 8. Requesting corrections and reprocessing emotion data

[1588] The server analyzes the modification request and regenerates the design using the generative AI model while referring to the emotional data, thereby providing a design that reflects the user's emotional state.

[1589] 9. Finalize and save the design

[1590] Once the user is satisfied with the final design, they press the "Confirm" button. The server stores this design data and, if necessary, sends it to the sewing factory as order data. This data includes design details, material information, production specifications, etc.

[1591] Specific examples

[1592] For example, if a user requests a "blue hoodie with a zipper on the hood and ribbed cuffs," and the system recognizes that the user is expressing a feeling of satisfaction (happiness), it will adjust the design to reflect that emotion, using more detail and colors that emphasize the user's emotions. The design will then be presented to the user.

[1593] In this way, by reflecting the user's emotions, it becomes possible to design original fashion items that are more personal and satisfying.

[1594] The processing flow will be explained below.

[1595] Step 1:

[1596] Users access the design platform using a web browser and enter their design ideas and requirements into an input form, including the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on hood, ribbed cuffs).

[1597] Step 2:

[1598] The device sends the input data to the server, which includes the design requests entered by the user.

[1599] Step 3:

[1600] For emotion recognition, the device uses a webcam and microphone to capture the user's facial expressions and tone of voice, which are then sent to the emotion engine in real time.

[1601] Step 4:

[1602] The server uses an emotion engine to analyze the user's emotions from the captured data, for example, by using facial expression analysis algorithms or voice analysis algorithms to identify the user's emotional state (e.g., joy, sadness, surprise, etc.).

[1603] Step 5:

[1604] The server analyzes the user's input data and emotional data, and uses a text analysis algorithm to break down the user's requests into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs). The emotional data is used to adjust and optimize the design elements.

[1605] Step 6:

[1606] The server references the sewing factory's constraints and rules, and calls a generative AI model to generate a design based on the user's requests and emotional data. Generative AI models use generative inverse competitive networks and transformer models, among other things. Emotional data is reflected in the color and design details.

[1607] Step 7:

[1608] The server sends the generated design data to the user's device, which includes a visual representation of the design and detailed specifications.

[1609] Step 8:

[1610] The device displays the received design data on a web page, where the user can visually check the generated design.

[1611] Step 9:

[1612] The user reviews the displayed design and enters specific changes based on their emotional state in the "Modification Request Form" (e.g., "The zipper on the hood should be a little longer"). The modification request and emotional data are then sent back to the server.

[1613] Step 10:

[1614] The server analyzes the modification request and regenerates the design using the generative AI model while referring to the emotional data, thereby providing a design that reflects the user's emotional state.

[1615] Step 11:

[1616] The server transmits new design data generated based on the modification request to the user's terminal, which then displays it again.

[1617] Step 12:

[1618] The user confirms the final design that satisfies them and presses the "Confirm" button, which confirms the final design.

[1619] Step 13:

[1620] The server stores the finalized design data and, if necessary, sends it to the sewing factory as order data, which includes details of the design, material information, production specifications, etc.

[1621] The above is the specific process flow for requesting the production of a fashion item, combining user input and emotion recognition.

[1622] Example 2

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

[1624] Conventional fashion design generation systems create designs based solely on the user's requests, making it difficult to reflect the user's emotions and latent needs. They also have problems with not being able to efficiently accommodate user requests for revisions, resulting in lower user satisfaction. Furthermore, it is difficult to generate designs that take into account the constraints of a sewing factory, often requiring numerous adjustments during the actual production process.

[1625] The specific processing by the specific processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes means for receiving user input data, means for collecting user emotional data using a webcam or microphone, means for analyzing the collected emotional data and identifying the user's emotional state, means for integrating the received input data and the analyzed emotional data and converting them into design elements, means for referring to the sewing factory's restrictions and rules and checking whether the design satisfies the restrictions, means for generating a fashion design based on the user's requests, emotional data, and restrictions using a generative AI model, means for displaying the generated design data to the user and receiving revision requests, means for re-analyzing the user's revision requests and emotional data and displaying the design regenerated by the generative AI model, and means for saving the finalized design data and, if necessary, transmitting it as order data to the sewing core industry. This enables personalized design generation that reflects the user's emotions, efficient revision support, and smooth production at the sewing factory.

[1626] "User input data" refers to requests and specification information regarding fashion items that users input through the design platform.

[1627] "Emotional data" refers to data on a user's facial expressions and voice collected using a webcam or microphone, and is used to analyze the user's emotional state.

[1628] An "emotion engine" is a system that includes algorithms and programs for analyzing collected emotional data and identifying the user's emotional state.

[1629] "Design elements" are information that refers to the characteristics and details of specific fashion items generated based on user input data and emotional data.

[1630] "Generative AI model" means an artificial intelligence model used to generate fashion designs based on user preferences, emotional data, and garment factory constraints, including a generative inverse competitive network or a transformer model.

[1631] "Sewing factory constraints" refers to information about factory equipment, technical constraints, and specifications that must be taken into consideration when actually producing fashion items.

[1632] "Order data" refers to data sent to a sewing factory that includes the finalized design data, necessary material information, production specifications, etc.

[1633] A "modification request" is a requirement that a user inputs in the form of specific instructions for changes to the generated design.

[1634] A "webcam" is an image input device used to collect facial expression data of a user.

[1635] A "microphone" is an audio input device used to collect data of a user's voice.

[1636] The present invention relates to a system for designing original fashion items using user emotional data and having the designs produced at a garment factory. This system involves a series of processes, starting with a user accessing a design platform and inputting their design requirements, followed by generating a design using an emotion recognition and generative AI model, and finally sending the finalized design to the garment factory.

[1637] System configuration

[1638] Hardware:

[1639] Terminal: The computer through which the user provides input.

[1640] Webcam: Image input device for collecting user facial expression data

[1641] Microphone: A voice input device for collecting data on the user's voice.

[1642] Server: A computer system that analyzes data and runs generative AI models.

[1643] software:

[1644] Design platform: a web application that provides the user interface

[1645] Emotion engine: Algorithms for analyzing user emotion data

[1646] Text analysis algorithms: Software that analyzes user input and converts it into design elements

[1647] Generative AI models: Artificial intelligence models for generating designs using generative inverse competitive networks (GANs) and transformer models.

[1648] Collecting user input and sentiment data

[1649] Users access the design platform and enter their design requirements into an input form. For example, they can enter specific requirements such as "a blue hoodie with a zipper on the hood and ribbed cuffs." At this time, the device's webcam and microphone are activated, and facial and voice data from the user is collected in real time.

[1650] Data analysis and design generation

[1651] The server uses an emotion engine to analyze the user's emotions from the collected facial and voice data. The analysis results indicate, for example, that the user is feeling "joy." The server then integrates the user's input data with the analyzed emotion data and converts it into design elements using a text analysis algorithm.

[1652] The server then calls up a generative AI model, taking into account the sewing factory's constraints, to generate a design based on the user's requests and emotional data. For example, the generative AI model might incorporate bright colors and detailed design elements to reflect the emotion of "joy."

[1653] View and modify the design

[1654] The generated design data is sent from the server to the user's device and displayed on a web page. The user can review the displayed design and input correction requests as needed. The correction requests and emotion data are sent back to the server, where the generative AI model regenerates the design, and the new design is provided to the user.

[1655] Final design confirmation and order placement

[1656] Once the user has confirmed the final design and clicked the "confirm" button, the server saves the design data. The saved design data is then sent to the sewing industry as order data. This data includes details of the design, material information, production specifications, etc.

[1657] Specific examples

[1658] For example, if a user requests a "blue hoodie with a zipper on the hood and ribbed cuffs," and the system recognizes that the user is expressing a feeling of satisfaction (happiness), it will adjust the design to reflect that emotion, using more detail and colors that emphasize the user's emotions. The design will then be presented to the user.

[1659] Prompt Sentence Examples

[1660] User input data:

[1661] Item Type: Hoodie

[1662] Color: Blue

[1663] Design elements:

[1664] Zipper on hood

[1665] Ribbed cuffs

[1666] User Emotion Data: Joy

[1667] Prompt statement:

[1668] "Based on the user's desire and emotional state, generate a design for a blue hoodie with a zippered hood and ribbed cuffs. The user is expressing the emotion of joy, so emphasize the design details and color."

[1669] By using these techniques, it is possible to design original fashion items that are personal and highly satisfying, reflecting the user's emotions.

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

[1671] Step 1: Receive user input

[1672] A user accesses the design platform using a web browser and inputs their design requirements. The input includes detailed information such as the type of item (e.g., hoodie, T-shirt), color, and design elements (e.g., zipper on the hood, ribbed cuffs). The input data is sent to the terminal through an input form. The terminal is responsible for sending this data to the server. Example of input data: "A blue hoodie with a zipper on the hood and ribbed cuffs."

[1673] Step 2: Collecting emotion data

[1674] The device activates the webcam and microphone to collect the user's facial and voice data. This data is captured in real time and sent to the emotion engine. The input data includes the user's facial images and voice recordings. The output data is the emotion data sent to the server.

[1675] Step 3: Analyze the emotion data

[1676] The server uses an emotion engine to analyze the collected facial expression data and voice data to identify the user's emotional state. It uses a facial expression analysis algorithm to analyze the facial expression data and a voice analysis algorithm to analyze the voice data. The resulting analysis results identify the user's emotional state (e.g., joy, sadness, surprise, etc.). The input data are facial expression and voice data, and the output data is the emotional state (e.g., the user is showing the emotion of "joy").

[1677] Step 4: Integrating and processing input and emotion data

[1678] The server combines the user's input data with the analyzed emotion data and converts it into design elements using a text analysis algorithm. The input data is broken down into individual design elements (e.g., color = blue, item = hoodie, detail 1 = zipper on hood, detail 2 = ribbed cuffs), and the emotion data is used to adjust the design elements. The input data are the user's desires and emotion data, and the output data are the analyzed design elements.

[1679] Step 5: Generate a design using the model

[1680] The server references the sewing factory's restrictions and rules and generates designs using a generative AI model. The generative AI model uses a generative inverse competitive network (GAN) or a transformer model to generate optimal designs based on the user's requests and emotional data. The input data are design elements and emotional data, and the output data is the generated design.

[1681] Step 6: View the generated design

[1682] The server sends the generated design data to the user's device, and the device visually displays the design on a web page, where the user can check the generated design. The input data is the generated design data, and the output data is the design displayed to the user.

[1683] Step 7: Verify and modify users

[1684] The user checks the displayed design and enters specific changes in the "Modification Request Form." For example, they can enter specific instructions such as "I want the zipper on the hood to be a little longer." The modification request and emotion data are sent back to the server. The input data are the modification request and emotion data, and the output data is the updated input data.

[1685] Step 8: Request corrections and reprocess emotion data

[1686] The server analyzes the revision request and regenerates the design using the generative AI model while referring to the emotional data. This generates a revised design that reflects the user's emotional state. The input data are the revision request and emotional data, and the output data is the regenerated design.

[1687] Step 9: Finalize and save your design

[1688] The user finally confirms the design to their satisfaction and presses the "confirm" button. The server saves this design data and sends it to the sewing industry as order data. The order data includes design details, material information, production specifications, etc. The input data is the confirmed design data, and the output data is the saved design data and order data.

[1689] (Application example 2)

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

[1691] In recent years, the demand for original fashion items has increased, and users tend to want designs based on their own emotions. However, current systems cannot recognize users' emotions and reflect them in the design, so they cannot fully meet this demand. Furthermore, even if users request revisions, the design is not regenerated taking into account their emotional data, which results in a decrease in user satisfaction.

[1692] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving user input data, means for analyzing the received input data and converting it into design elements, means for recognizing and analyzing the user's emotional data, means for adjusting the design elements based on the emotional data, means for referencing the sewing factory's constraints and rules and confirming whether the design satisfies the constraints, means for generating a fashion design based on the user's requests, constraints, and emotional data using a generative AI model, means for displaying the generated design data to the user and receiving revision requests, means for reanalyzing the user's revision requests and emotional data and displaying the design regenerated by the generative AI model, and means for saving the finalized design data and, if necessary, transmitting it to the sewing factory as order data. This makes it possible to generate and modify designs that reflect the user's emotions.

[1693] "Means for receiving user input data" refers to means for providing an interface for users to input information such as design requests and ideas into the system.

[1694] "Means for analyzing received input data and converting it into design elements" refers to the algorithms or processes used to break down the input data received from the user into individual elements, analyze them, and convert them into design elements.

[1695] "Means for recognizing and analyzing user emotional data" refers to hardware and software for collecting and analyzing user emotions using technologies such as facial recognition and voice analysis.

[1696] "Means for adjusting design elements based on emotional data" refers to a mechanism for optimizing and adjusting design elements based on acquired emotional data, making it possible to fine-tune the design to reflect the user's emotions.

[1697] "Means of referencing the constraints and rules of the garment factory and verifying that the design meets the constraints" refers to a process or system for referencing the technical and manufacturing constraints and rules of the garment factory and verifying that the generated design meets these conditions.

[1698] "Means for using a generative AI model to generate fashion designs based on user requests, constraints, and emotional data" refers to means for using a generative AI model such as a generative inverse competitive network or a transformer model to create fashion designs based on user requests, constraints of a garment factory, and emotional data.

[1699] "Means for displaying the generated design data to the user and receiving revision requests" refers to means for visually presenting the generated design data to the user and providing an interface for inputting revision requests from the user.

[1700] "Means for re-analyzing the user's revision requests and emotional data, and displaying a design re-generated by the generative AI model" refers to means for analyzing the user's revision requests and emotional data, re-generating a design using the generative AI model, and presenting it to the user.

[1701] "Means for saving the finalized design data and sending it to the sewing factory as order data as necessary" refers to the process for saving the design data that has been finalized by the user in the system and sending that data to the sewing factory as a production request.

[1702] The present invention is a system that recognizes a user's emotions and designs original fashion items based on those emotions. Specific embodiments of the system will be described below.

[1703] The system mainly consists of a terminal that receives user input data, a means for recognizing and analyzing emotional data, a means for generating designs using a generative AI model, and an interface for displaying and modifying the generated design data.

[1704] Configuration details

[1705] 1. Receiving and analyzing input data

[1706] A device (such as a smartphone or head-mounted display) receives design requests and ideas from users through an input form. The user's input data is sent to a server, which then analyzes the data using a text analysis algorithm (such as natural language processing technology) and converts it into design elements.

[1707] 2. Emotion Data Recognition and Analysis

[1708] The device's built-in camera and microphone are used to capture the user's facial expressions and tone of voice in real time. This emotional data is then analyzed using libraries such as TensorFlow and OpenCV. The server then determines the user's emotional state based on this emotional data.

[1709] 3. Design Generation

[1710] The server invokes a generative AI model using a generative inverse competitive network (GAN) or a transformer model based on the user's input data and emotional data. The generative AI model generates a design that reflects the user's wishes and emotional state. It also references the sewing factory's constraints and rules, adjusting the generated design to meet these conditions.

[1711] 4. View and modify the design

[1712] The generated design data is then sent back to the device and visually presented to the user. The user can then input any modifications they wish to make to the design into the system. The modifications are then analyzed again by the server, and the generative AI model generates a re-created design based on the emotion data.

[1713] 5. Finalize and save the design

[1714] Once the user is satisfied with the final design and presses the "confirm" button, the server saves the design data and sends it to the sewing factory as order data, including design details, material information, and production specifications.

[1715] Specific examples

[1716] For example, a user uses a smartphone to enter the following request:

[1717] "I want a red dress with a heart pattern scattered all over it."

[1718] If the user responds to this input with an emotion of "happiness," the system generates a warm color scheme and design that reflects that emotion. The user reviews the design and can enter the following if further adjustments are needed:

[1719] "Make the heart pattern bigger and add ruffles to the bottom of the dress."

[1720] The generative AI model then reflects this again to generate a new design and present it to the user.

[1721] Prompt Sentence Examples

[1722] User design request: "A red dress with a heart pattern scattered all over it."

[1723] User sentiment: "Happy"

[1724] Design generation requirements:

[1725] 1. Red tones

[1726] 2. Scatter heart patterns all over the piece

[1727] 3. A design with warm colors and a fun atmosphere based on a sense of happiness

[1728] In this way, it is possible to provide more personalized and high-quality fashion designs by reflecting the user's emotions.

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

[1730] Step 1:

[1731] The device receives the user's input data. This is the process of the user entering their design requirements into an input form via a smartphone or head-mounted display. For example, a request might be "I want a red dress with a scattered heart pattern." This data is then sent from the device to the server.

[1732] Step 2:

[1733] The server analyzes the input data it receives and converts it into design elements. The input data is broken down into individual elements using a text analysis algorithm (such as natural language processing technology), and then analyzed. For example, the data is converted into design elements such as "red," "dress," and "heart pattern."

[1734] Step 3:

[1735] The device recognizes and collects the user's emotional data, using a camera and microphone to capture the user's facial expressions and tone of voice, and transmits this emotional data to a server in real time.

[1736] Step 4:

[1737] The server analyzes the emotion data. Using libraries such as TensorFlow and OpenCV, it analyzes the captured facial and voice data to identify the user's emotional state (e.g., happiness, surprise, sadness, etc.). The analysis result is an emotional state such as "happiness."

[1738] Step 5:

[1739] The server generates designs based on input data and emotion data. Using a generative inverse competitive network (GAN) or a transformer model, it generates designs based on the user's requests and emotion data. It also references the sewing factory's constraints and rules and adjusts them to meet these. The generated designs are compiled as design data.

[1740] Step 6:

[1741] The server sends the generated design data to the user's device, which then visually displays the design data to the user, who then confirms the generated design.

[1742] Step 7:

[1743] The user inputs specific requests for modifications to the design, such as "make the heart pattern bigger and add frills to the bottom of the dress." This data is then sent back to the server.

[1744] Step 8:

[1745] The server analyzes the modification request and emotion data and regenerates the design. A new design is generated based on the modification request and emotion data using the regeneration AI model. This process regenerates the modified design data.

[1746] Step 9:

[1747] The server sends the regenerated design data to the user's terminal, which again displays it to the user. This step is repeated until the user confirms the regenerated design and is finally satisfied.

[1748] Step 10:

[1749] The user finally decides on a design they are satisfied with. Once the user presses the "Confirm" button, the server saves the final design data. This data is then sent to the sewing factory as order data, including design details, material information, and production specifications.

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

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

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

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

[1754] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

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

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

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

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

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

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

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

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

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

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

[1765] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

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

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

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

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

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

[1771] The following is further disclosed regarding the above embodiment.

[1772] (Claim 1)

[1773] a means for receiving user input data;

[1774] a means for parsing and converting received input data into design elements;

[1775] A means to refer to the sewing factory's restrictions and rules and ensure that the design meets the restrictions.

[1776] A means for generating fashion designs based on user requests and constraints using a generative AI model;

[1777] means for displaying the generated design data to a user and receiving requests for modifications;

[1778] A means for re-analyzing the user's modification request and displaying the regenerated design by the generative AI model;

[1779] A means for saving the finalized design data and sending it to a sewing factory as order data as needed;

[1780] A system including:

[1781] (Claim 2)

[1782] 10. The system of claim 1, further comprising means for analyzing user input data using a text analysis algorithm.

[1783] (Claim 3)

[1784] 10. The system of claim 1, further comprising means for using a generative inverse competitive network or a transformer model as the generative AI model.

[1785] "Example 1"

[1786] (Claim 1)

[1787] a means for receiving user input data;

[1788] a means for parsing and converting received input data into design elements;

[1789] A means to refer to the sewing factory's restrictions and rules and ensure that the design meets the restrictions.

[1790] A means for generating fashion designs based on user requests and constraints using a generative AI model;

[1791] means for displaying the generated design data to a user and receiving requests for modifications;

[1792] A means for re-analyzing the user's modification request and displaying the regenerated design by the generative AI model;

[1793] A means for saving the finalized design data and sending it to a sewing factory as order data as needed;

[1794] A means for transmitting the received design data to the user's terminal using a web browser;

[1795] a means for storing design elements in a database and retrieving sewing factory constraints from an internal database;

[1796] A way to receive user input in real time and wait for the submit button to be clicked,

[1797] A system including:

[1798] (Claim 2)

[1799] 10. The system of claim 1, further comprising means for analyzing user input data using a text analysis algorithm.

[1800] (Claim 3)

[1801] 10. The system of claim 1, further comprising means for using a generative inverse competitive network or a transformer model as the generative AI model.

[1802] "Application Example 1"

[1803] (Claim 1)

[1804] a means for receiving user input data;

[1805] a means for parsing and converting received input data into design elements;

[1806] means for transmitting the analyzed design elements to a server via a communication network;

[1807] A means of checking whether the design satisfies the constraints and rules of the sewing facility equipped on the server;

[1808] A means for generating fashion designs based on user requests and constraints using a generative AI model;

[1809] a means for displaying the generated design data on a user's mobile device and receiving a request for modification;

[1810] a means for re-analyzing the user's modification request and displaying the regenerated design by the generative AI model on the user's mobile device;

[1811] A means for storing the finalized design data and transmitting it to a sewing facility as order data as necessary;

[1812] A system that includes a means for users to purchase items designed by them.

[1813] (Claim 2)

[1814] 10. The system of claim 1, further comprising means for analyzing user input data using a text analysis algorithm.

[1815] (Claim 3)

[1816] 10. The system of claim 1, further comprising means for using a generative inverse competitive network or a transformer model as the generative AI model.

[1817] "Example 2: Combining Emotion Engines"

[1818] (Claim 1)

[1819] a means for receiving user input data;

[1820] A means of collecting user emotional data using a webcam and microphone;

[1821] means for analyzing the collected emotional data to identify the user's emotional state;

[1822] a means for integrating the received input data with the analyzed emotion data and converting them into design elements;

[1823] A means to refer to the sewing factory's restrictions and rules and ensure that the design meets the restrictions.

[1824] A means for generating fashion designs based on user requests, emotional data, and constraints using a generative AI model;

[1825] means for displaying the generated design data to a user and receiving requests for modifications;

[1826] A means for re-analyzing the user's modification requests and emotional data and displaying the regenerated design by the generative AI model;

[1827] A means for storing the finalized design data and transmitting it as order data to the sewing core industry as necessary;

[1828] A system including:

[1829] (Claim 2)

[1830] 10. The system of claim 1, further comprising means for analyzing user input data using a text analysis algorithm.

[1831] (Claim 3)

[1832] 10. The system of claim 1, further comprising means for using a generative inverse competitive network or a transformer model as the generative AI model.

[1833] "Application example 2 when combining emotion engines"

[1834] (Claim 1)

[1835] a means for receiving user input data;

[1836] a means for parsing and converting received input data into design elements;

[1837] means for recognizing and analyzing user emotional data;

[1838] a means of adjusting design elements based on emotional data;

[1839] A means to refer to the sewing factory's restrictions and rules and ensure that the design meets the restrictions.

[1840] A means for generating fashion designs based on user requests, constraints, and emotional data using a generative AI model;

[1841] means for displaying the generated design data to a user and receiving requests for modifications;

[1842] A means for re-analyzing the user's modification request and emotion data and displaying the regenerated design by the generative AI model;

[1843] A means for saving the finalized design data and sending it to a sewing factory as order data as needed;

[1844] A system including:

[1845] (Claim 2)

[1846] 10. The system of claim 1, further comprising means for analyzing user input data using a text analysis algorithm.

[1847] (Claim 3)

[1848] 10. The system of claim 1, further comprising means for using a generative inverse competitive network or a transformer model as the generative AI model. [Explanation of symbols]

[1849] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. a means for receiving user input data; a means for parsing and converting received input data into design elements; A means to refer to the sewing factory's restrictions and rules and ensure that the design meets the restrictions. A means for generating fashion designs based on user requests and constraints using a generative AI model; means for displaying the generated design data to a user and receiving requests for modifications; A means for re-analyzing the user's modification request and displaying the regenerated design by the generative AI model; A means for saving the finalized design data and sending it to a sewing factory as order data as needed; A system including:

2. 10. The system of claim 1, further comprising means for analyzing user input data using a text analysis algorithm.

3. 10. The system of claim 1, further comprising means for using a generative inverse competitive network or a transformer model as the generative AI model.

Images