Intelligent clothing pattern generation method and system based on designer acceptance

Abstract

The invention discloses an intelligent clothing pattern generation method and system based on designer acceptance, and the method comprises the steps: building a lightweight heuristic acceptance scoring model through collecting the multi-dimensional behavior feedback of a designer for AI generated clothing design in real time, and dynamically quantifying the acceptance degree of the designer for a system generation result; in combination with information of different stages of the design process, the system maps acceptance and stage labels to key control parameters of a generation model, and diversified output adjustment for creation progress is achieved; based on an improved Stable Diffusion generation engine, the system adopts a framework combining a frozen basic network and a trainable copy, dynamic control signals are injected through a zero convolutional layer, and the style complexity, detail richness and fidelity of a generated image are flexibly adjusted. According to the method, the interaction efficiency and the personalized adaptation capability of the AI aided design are effectively improved.

Description

Technical Field

[0001] The present invention belongs to the technical field of intelligent clothing pattern generation, and in particular relates to an intelligent clothing pattern generation method and system based on designer acceptance. Background Art

[0002] With the development of artificial intelligence (AI) generative models, particularly the widespread application of diffusion models, generative adversarial networks, and large-scale text-image pre-training models (such as DALLE and Stable Diffusion) in image generation, initial explorations of AI-generated image-assisted design have begun to emerge in the field of fashion design. These systems primarily rely on image generation networks driven by text prompts to provide designers with sketches, renderings, and even finished product images. However, in the actual design process, designers' acceptance of AI-generated content often exhibits significant individual differences and periodic fluctuations, influenced not only by the current creative task but also by their personal style, aesthetic preferences, and subjective judgment of the system's output quality. Existing AIGC clothing image generation methods are unable to perceive and adapt to changes in designer acceptance and make targeted adjustments, resulting in results that deviate from design preferences and severely limiting creative efficiency. Therefore, a mechanism that can continuously perceive designer behavioral feedback and adjust generation strategies accordingly is urgently needed to achieve a higher level of human-machine collaboration. In this context, introducing designer acceptance as a core indicator for regulating the generation process can effectively capture designers' acceptance and willingness to use system-generated content at different design stages.

[0003] Most current mainstream AI clothing generation systems are based on large, open-source models (such as Stable Diffusion, MidJourney, and DALL E). Their underlying architecture consists of a text encoder (such as CLIP), an image encoder (such as VAE), and an image generator based on a U-Net or Transformer architecture. Users input free-text prompts to drive the image synthesis process. The model first maps the prompts into semantic embeddings, then gradually generates latent space images through multiple rounds of diffusion sampling, ultimately decoding them into high-resolution rendered images. Building on this, some systems attempt to improve the stability and style consistency of image generation through prompt optimization mechanisms. These methods do not modify the generative model itself, but instead process the prompt input layer. For example, some studies have introduced prompt enhancement techniques to automatically add auxiliary vocabulary such as style keywords, tailoring terms, and material descriptions to the original text, making the prompts more professional and artistically instructive. Other systems have introduced style templates or keyword rewriting strategies, leveraging designer-preset style structures or design tag libraries to structurally restructure the original prompts, thereby improving the consistency and diversity of the generated output. This type of approach primarily relies on natural language processing capabilities, often incorporating LLMs or design domain semantic graphs for semantic reconstruction. These approaches are suitable for generating initial drafts of styles or rapid design ideation. Another approach improves the level of personalization by incorporating user feedback mechanisms. Specifically, these systems not only receive prompt input but also collect explicit or implicit user behavior data during usage, such as whether an image is saved, deleted, or used as the basis for subsequent design evolution, as well as the duration of time spent on the image and click behavior. This interaction data is used as feedback to dynamically adjust the direction of subsequent image generation. Some systems employ heuristic scoring methods to construct simple preference models, while others attempt to construct more complex user interest prediction mechanisms through collaborative filtering, reinforcement learning, or graph neural networks. Furthermore, to further enhance the refined control capabilities of image generation, some systems employ control generation mechanisms based on structure-guided graphs. Control flow modeling approaches, represented by architectures such as ControlNet and T2I-Adapter, typically incorporate additional inputs such as edge maps, depth maps, segmentation maps, or sketches. These control branches then inject structural information into the intermediate layers of the generative backbone network. This type of method significantly improves the structural consistency and detail retention capabilities of clothing images, and is effective in tasks such as local image modification, style transfer, and clothing reconstruction.

[0004] Disadvantages of existing technologies: For image generation methods driven by text prompts, such methods rely on static natural language input for image generation, lack the perception and modeling of the designer's interactive behavior during actual use, and cannot dynamically adjust according to the designer's acceptance of the generated results or modification behavior. As a result, the generated content is difficult to match the designer's true intentions in terms of style, detail, and complexity, reducing the effectiveness of auxiliary design. For methods that improve image generation through prompt word optimization mechanisms, their optimization process is usually independent of the designer's real-time feedback and creation stage, lacking the ability to adaptively adjust based on interactive behavior, making it difficult to achieve coordinated control of generation strategies and design progress, resulting in auxiliary content being out of touch with current design needs. For methods that improve the degree of personalization of generation by introducing user feedback mechanisms, most existing methods remain at the heuristic analysis level of explicit feedback, lack systematic modeling and dynamic quantification of acceptance, and fail to effectively embed this trust information into the control process of the generation model, making it difficult to establish a sustainable and effective trust enhancement mechanism. For the control generation mechanism method based on structure-guided graphs, its control signals are usually static graphic inputs, which are not dynamically adjusted in combination with the designer's interactive behavior or creative stage. It lacks semantic adaptability and behavioral linkage mechanism, which limits its applicability and flexibility in multi-stage design processes. Summary of the Invention

[0005] To solve the above technical problems, the present invention proposes an intelligent clothing pattern generation method and system based on designer acceptance, which effectively improves the interaction efficiency and personalized adaptation capabilities of AI-assisted design, and provides the clothing design industry with an intelligent, dynamic and reliable auxiliary creation solution.

[0006] In order to achieve the above-mentioned object, the present invention provides a method for generating intelligent clothing patterns based on designer acceptance, comprising:

[0007] Real-time collection of designer interaction data on AI-generated clothing images;

[0008] Calculating a dynamic acceptance value based on the type and duration of the interaction behavior data;

[0009] mapping the acceptance value and the current design stage label to control parameters of an image generation model;

[0010] Garment images are generated via a hybrid architecture consisting of a frozen backbone network and a trainable control path, where the control signal is injected into the backbone network via zero-initialized convolutional layers.

[0011] On the other hand, to achieve the above-mentioned purpose, the present invention further provides an intelligent clothing pattern generation system based on designer acceptance, comprising:

[0012] An acceptance calculation module is used to collect in real time the designer's interactive behavior data on the AI-generated clothing images and calculate a dynamic acceptance value based on the type and duration of the interactive behavior data;

[0013] a control parameter mapping module, configured to map the acceptance value and the current design stage label to control parameters of an image generation model;

[0014] The clothing image generation module is used to generate a clothing image according to the control parameters, wherein the control signal is injected into the backbone network through the zero-initialized convolution layer.

[0015] Technical effects of the invention: The present invention discloses an intelligent clothing pattern generation method and system based on designer acceptance. The method adopts a zero convolution layer to dynamically inject control signals to ensure fine-grained adjustment of the generation process. At the same time, the model stability reduces the fluctuation amplitude by about 10%, avoiding performance degradation. Driven by acceptance, the style diversity entropy of a single batch generation (8 pictures) is increased by 2.1 times. The probability of users performing the "evolution" operation in a high-trust state is significantly increased, indicating that the system effectively stimulates creative extension. The acceptance is modeled in real time through multi-dimensional designer behavior data, which significantly improves the accuracy of capturing designer preferences and increases user satisfaction by about 15%-20%. Based on the acceptance adjustment mechanism of continuous interactive feedback, the number of design iterations is significantly reduced. In the process from "sketch" to "drawing", the cross-stage retention rate of core design elements (such as silhouette / material) reaches 92%; the number of control path parameters is only 36 million (accounting for 10% of the backbone network), and the training energy consumption is significantly reduced. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] The accompanying drawings, which constitute part of this application, are intended to provide a further understanding of this application. The exemplary embodiments and descriptions of this application are intended to explain this application and do not constitute an improper limitation on this application. In the accompanying drawings:

[0017] Figure 1 This is a flow chart of a method for generating intelligent clothing patterns based on designer acceptance according to an embodiment of the present invention;

[0018] Figure 2 This is a schematic diagram of the architecture of a model for dynamically controllable generation of clothing images according to an embodiment of the present invention;

[0019] Figure 3 This is a structural diagram of an intelligent clothing pattern generation system based on designer acceptance according to an embodiment of the present invention. DETAILED DESCRIPTION

[0020] It should be noted that, in the absence of conflict, the embodiments and features of the embodiments in this application can be combined with each other. The present application will be described in detail below with reference to the accompanying drawings and in combination with the embodiments.

[0021] It should be noted that the steps shown in the flowcharts of the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions, and that, although a logical order is shown in the flowcharts, in some cases, the steps shown or described can be executed in an order different from that shown here.

[0022] like Figure 1 As shown, this embodiment provides a method for generating intelligent clothing patterns based on designer acceptance, including:

[0023] Real-time collection of designer interaction data on AI-generated clothing images;

[0024] Calculating a dynamic acceptance value based on the type and duration of the interaction behavior data;

[0025] mapping the acceptance value and the current design stage label to control parameters of an image generation model;

[0026] Garment images are generated via a hybrid architecture consisting of a frozen backbone network and a trainable control path, where the control signal is injected into the backbone network via zero-initialized convolutional layers.

[0027] Furthermore, the interaction behavior data includes the designer's adoption operation, evolution operation, save operation, rejection operation and image hovering time of the generated image;

[0028] The process of calculating the dynamic acceptance value includes: assigning a first positive weight to the adoption operation; assigning a second positive weight to the evolution operation; assigning a third positive weight to the save operation; assigning a negative weight to the rejection operation; and converting the hovering duration through a nonlinear function and then participating in the calculation.

[0029] Furthermore, the process of calculating the dynamic acceptance value also includes:

[0030] Initialize the acceptance to a neutral value of 0.5;

[0031] Dynamically update the acceptance value based on the behavior weight;

[0032] The real-time acceptance value is limited to the preset closed interval [0.1, 1.0] and transmitted to the generation module.

[0033] Furthermore, the hybrid architecture of the image generation model includes:

[0034] A frozen pre-trained clothing image generation network, including a text encoder, a latent space encoder, and a U-Net denoising network;

[0035] A trainable control path that mirrors part of the encoder structure of the U-Net network;

[0036] A zero-initialized convolutional layer is connected between the output of the control path and the backbone network.

[0037] Furthermore, the process of mapping the control parameters includes:

[0038] When acceptance increases, the semantic guidance intensity is reduced to increase creative divergence;

[0039] When acceptance decreases, the semantic guidance strength is enhanced to ensure output stability;

[0040] Automatically adjust the style complexity, detail fidelity, and number of generated output images based on design-stage labels.

[0041] Furthermore, the design stage labels include five categories: inspiration generation, sketching, material color matching, detail control, and final rendering.

[0042] Furthermore, the process of adjusting the output image includes:

[0043] In the inspiration generation or sketching stage and when the acceptance level is higher than a first threshold, multiple concept images with divergent compositions are output;

[0044] During the inspiration generation or sketch drafting stage and when the acceptance level is lower than the second threshold, a small number of reference sketches with clear structures are output;

[0045] In the detail control or final rendering stage and when the acceptance level is higher than a first threshold, a high-fidelity image is output;

[0046] In the detail control or final rendering stage and when the acceptance level is lower than a second threshold, a local close-up image is output.

[0047] Furthermore, the training process of the trainable control path includes:

[0048] Randomly sample acceptance values ​​and design-stage labels in the training batch;

[0049] Add the control signal to the frozen network through residual injection;

[0050] Minimize the noise prediction error and jointly optimize the perceptual loss and style preservation loss.

[0051] Specifically, Figure 1The intelligent clothing pattern generation method and system based on designer acceptance begins with the designer inputting a text prompt and selecting a creative stage. The system then generates a first batch of basic designs. The designer's interactive behaviors, such as adoption, evolution, or disregard of these designs, are captured in real time by an event-driven acceptance calculation model and quantified as a dynamic "real-time acceptance T-value." This acceptance value, along with the original prompt and creative stage information, serves as the core control variable and is input into the dynamic, controllable clothing image generation module. The adaptive control engine within this module dynamically adjusts key generation parameters, such as the CFG scale, based on the acceptance level. Furthermore, through a U-Net architecture with a trainable control path, the generated image's stylistic divergence and creativity are directly controlled without changing the original prompt. Ultimately, a new design that better meets the designer's implicit expectations is generated and presented, awaiting the next round of designer interaction, thus forming a continuously self-optimizing, intelligent design closed loop.

[0052] Figure 2 The architecture of the dynamic, controllable generative model for clothing images takes as input a cue word, creation stage, real-time acceptance, latent variables, and time steps. The system calculates configuration parameters such as the dynamic CFG scale based on the acceptance T and stage S, thereby outputting control conditions. The generative model utilizes a dual-path U-Net architecture, with a trainable control path injecting control signals into a frozen U-Net backbone via zero-convolutional layers. Ultimately, the entire denoising process on the latent variables simultaneously receives semantic guidance from the cue word and stylistic divergence control from the dynamic CFG, generating highly customized clothing images.

[0053] The acceptance calculation module in the system is an event-driven model that is executed in real time at high frequency. Its input comes from the interaction behavior data between designers and the AI ​​generation system. Specific input indicators include: adoption operation, which refers to the user explicitly clicking "Adopt" in the multi-image output or selecting a certain image as the final sketch. This operation is recorded by the system as a positive feedback event; evolution operation, which refers to the user clicking "Generate More Similar" or redesigning based on a certain image. This behavior reflects the user's affirmation of the original image in the creative direction; save operation, which means the user adds the image to favorites, saves it locally, or exports it to other modules, indicating that the image has certain use value; rejection operation, which means the user explicitly clicks buttons such as "Delete", "Unsatisfied", and "Exclude". This behavior is regarded as a rejection of the generated image; hover behavior, which is the time (in seconds) that the user keeps the cursor on an image, reflecting the user's interest in the image.

[0054] These inputs are collected in real time by the front-end interactive system and converted into structured event streams. Each behavior is assigned a corresponding numerical weight. The system sets the initial acceptance level to T0 = 0.5 and uses the following weighted update mechanism to recursively calculate the acceptance level:

[0055]

[0056] in, W represents the weight value of the jth discrete behavior event, which is specifically set as: Adopt event: +0.15, Evolve event: +0.10, Save event: +0.05, Reject event: -0.08. dwell (t j ) indicates the hovering time t j The weighting function of is defined as a nonlinear logarithmic decreasing function:

[0057] W dwell (t) = 0.02·log2(1+t);

[0058] For example, if a user stays on a certain image for 8 seconds, the image will contribute W dwell =0.02·log2(9)≈0.063. The system updates the acceptance T after each interaction, and the value range is limited to [0.1, 1.0] to avoid boundary oscillation. This acceptance value is transmitted to the generation system in real time and serves as the core control variable affecting generation parameters (such as CFG Scale, image output type, generation style range, and quantity).

[0059] The dynamic and controllable clothing image generation module is built on the Stable Diffusion v1.5 model. This basic model consists of a frozen backbone network, including a text encoder, a latent space encoder, and a U-Net denoising main network. The text encoder uses CLIP ViT-L / 14 to convert the prompt word into a 768-dimensional semantic embedding. The VAE module compresses the image into a 64×64×4 latent variable space. The core denoising module is a symmetrical U-Net network consisting of a 4-layer downsampling encoder, a 1-layer bottleneck layer, and a 4-layer upsampling decoder. Each layer contains a ResNet residual block and a Cross-Attention module to introduce semantic guidance.

[0060] To introduce control over receptivity, the system constructed a trainable replica of the U-Net. This architecture mirrors the first 13 modules of the main network (i.e., the encoder and bottleneck layers). A 1×1 convolutional layer (ZeroConv) is inserted between each module. Initially, the parameters of this layer are set to zero, ensuring that the system behaves consistent with the original model when unmodulated. During training, the control path introduces adjustable signals into the main network via ZeroConv. This control method uses "additive injection": the output of each module is transformed by ZeroConv and then added to the input of the same layer in the main network to form a fusion channel.

[0061] Under the premise that the prompt word remains unchanged, the system calculates the Classifier-Free Guidance Scale (CFG) parameters in the sampling phase based on the real-time acceptance T. The mapping logic is as follows:

[0062]

[0063] The exponent of 0.75 ensures that high confidence intervals are more sensitive to CFG control. That is, higher confidence leads to smaller CFG and more divergent image generation; conversely, lower confidence leads to a more conservative system. This function is derived from experimental fitting, and its specific form can be adjusted based on system tuning requirements to balance style divergence and generation stability.

[0064] In addition, the system labels five typical creative stages (inspiration generation, rough drafting, material color matching, detail control, and final rendering). Each stage corresponds to a different image output format, such as color sketch, line draft, material map display, detailed local map, or high-fidelity simulation. The stage label and acceptance level jointly determine: the style complexity of the output image (realistic / conceptual), image fidelity (blurred / high-definition), the number of outputs (1-10), and whether style diffusion is enabled (same style / divergent). For example, when the stage is "sketching" and the acceptance level is low (T≈0.2), the system sets the CFG to 10.2, and the output result is two linear sketches. However, when the acceptance level increases to T≈0.9 and the user enters the "inspiration generation" stage, the CFG drops to 3.9, and the output may be eight conceptual style images, whose composition, materials, and colors allow for more nonlinear exploration and creative leaps.

[0065] The final image is obtained through iterative inference by a sampler (such as DDIM or PLMS). The number of samples, image resolution, and random seed are uniformly configured by the control engine. The entire generation chain is driven by the triple conditions of "prompt word + acceptance + stage information", forming a closed loop for real-time, stage-adaptive, and personalized clothing image generation.

[0066] The model training phase is mainly focused on the trainable control path. The basic image generation network uses the Stable Diffusion model v1.5, and its backbone network (including the U-Net denoising module, CLIP text encoder, and VAE latent space mapper) keeps the weights frozen. The system introduces a trainable control path that is completely symmetrical with the structure of the U-Net backbone encoder. This path contains 12 encoder modules and 1 bottleneck module. Each module includes a convolution block, a residual block, and a self-attention mechanism, with a total of approximately 360 million parameters. A 1×1 zero convolution layer (ZeroConv) is connected after the output of each module. The number of parameters is extremely low, and the initial value is set to all zeros to ensure that the representation ability of the backbone network is not affected in the early stages of training.

[0067] The training process uses the image-prompt word pair (x, y) as the basic sample. The image x is first encoded into the latent variable z0 = VAE Enc ( x ), and the prompt word y is encoded into a semantic embedding vector E by the CLIP text encoder y During the training process, the system simulates the reverse process of diffusion sampling, which converts random noise into Add to the latent variable to construct a noisy sample:

[0068]

[0069] Where t∈[1,T] represents the number of diffusion steps, is the coefficient in the standard scheduling table. U-Net backbone network is t Perform denoising operation, whose input includes the noise latent variable z t , time step t and semantic vector E y , and the control path embeds the acceptance T and the design stage S and maps them into the control signal c, which is injected as follows:

[0070]

[0071] in is the output of the backbone network at layer i, ControlUNet i Represents a trainable control path, ZeroConv i represents the zero-convolution injection layer at layer i. This structure can be viewed as a form of “fine-tunable residual control”, where the control branches apply fine-grained adjustments layer by layer while the backbone maintains stable expressiveness.

[0072] The system training goal is to minimize the prediction noise The difference between ∈ and the true noise ∈ constitutes the basic loss function:

[0073]

[0074] in is the network output after including the control path. In order to improve visual consistency and structural control stability, a perceptual loss term can be added in the later training stage. (Based on VGG feature space) and style-preserving regularization The final comprehensive loss is:

[0075]

[0076] Among them, λ1 and λ2 are adjustment factors. The training adopts AdamW optimizer, and the initial learning rate is set to 1×10 -5 , the gradient clipping threshold is 1.0, the batch size is usually 64, and the total number of training iterations depends on the amount of data and convergence.

[0077] To ensure the generalization of the control path, the receptivity T is sampled within the range of [0.1, 1.0] during training, and the five stage labels S (inspiration, sketch, material, detail, and finished image) are randomly combined. This allows the model to learn the correspondence between (T, S) combinations and generated styles. The resulting trained model can dynamically respond to arbitrary receptivity inputs during inference and adapt the style control parameters of the output image based on the current stage of the design process, achieving adaptive image generation based on interactive feedback and design intent.

[0078] like Figure 3 As shown, this embodiment also provides an intelligent clothing pattern generation system based on designer acceptance, including:

[0079] An acceptance calculation module is used to collect in real time the designer's interactive behavior data on the AI-generated clothing images and calculate a dynamic acceptance value based on the type and duration of the interactive behavior data;

[0080] a control parameter mapping module, configured to map the acceptance value and the current design stage label to control parameters of an image generation model;

[0081] The clothing image generation module is used to generate a clothing image according to the control parameters, wherein the control signal is injected into the backbone network through the zero-initialized convolution layer.

[0082] Specifically, the acceptance calculation module and the clothing image dynamic and controllable generation module establish a linkage relationship through the intermediate variable "real-time acceptance value" and jointly serve the dynamic and controllable clothing creative image generation task.

[0083] The acceptance calculation module collects real-time data on designers' interactive behaviors, including adoption, evolution, save, rejection, and image hover duration. This module uses a weighted mechanism to process this behavioral data: adoption is assigned a positive weight, evolution is assigned the second-highest positive weight, save is assigned a base positive weight, and rejection is assigned a negative weight. Hover duration is then converted using a nonlinear function and included in the calculation. The system initializes acceptance to a neutral value and dynamically updates it based on the behavioral weights. The real-time acceptance value is then confined to a pre-set closed interval and transmitted to the generation module.

[0084] The controllable image dynamic generation module first maps real-time acceptance to key parameters: as acceptance increases, the semantic guidance strength is reduced to stimulate creative divergence, while as acceptance decreases, the guidance strength is increased to ensure output stability. Simultaneously, the output image's style complexity, detail fidelity, and number of generated images are automatically adjusted based on the design phase (inspiration generation, sketching, material color matching, detail control, and final rendering), outputting control conditions. The image generation model is based on a frozen, pre-trained clothing image generation model and comprises a text encoder, a latent space encoder, and a U-Net denoising main network. To achieve dynamic control, the system adds a trainable control path—this path replicates part of the U-Net encoder structure of the base generation network and inserts a 1×1 convolutional layer initialized to zero at each layer output. The control path receives real-time acceptance and design-stage labels. The generated control signal is injected into the main network via residual superposition via the convolutional layers, forming a hybrid architecture of "frozen backbone + adjustable replica."

[0085] The system employs a highly modular and logically closed-loop architecture, built around a four-stage process: "Designer Behavior Perception - Trust Modeling - Generation Strategy Control - Image Synthesis Feedback." Physically, it employs a decoupled front-end and back-end architecture, with core control logic centralized in the back-end generation service system, while the front-end handles event collection and parameter transmission. The overall system structure can be viewed as an intelligent generation loop driven by behavioral flows. Its component modules achieve asynchronous coupling and orderly scheduling through a set of structured state variables (including acceptance values, stage labels, and feedback flags).

[0086] In this architecture, the acceptance modeling subsystem is located at the inlet of the overall data flow and serves as the preemptive control source for generation scheduling. This subsystem communicates with the user interaction layer in real time, recording behavioral data and immediately completing state updates when events occur. It generates a floating-point acceptance coefficient T∈[0.1,1.0], which serves as the master control signal for the downstream image generation control module. The acceptance state is continuously maintained by the system and pushed to the scheduling engine via a message channel or internal shared memory mechanism. Simultaneously, the system identifies the creative stage state s based on the user's current operational context. This state is represented by five discrete classification labels, corresponding to the five typical stages of the clothing design process. Acceptance and stage labels form a set of joint control factors, constituting the current "generation intention state."

[0087] After this intention state is fed into the control mapping module, it is mapped into an image generation control packet. Its internal parameters include the CFGScale value, output image format instructions, number of images to be generated, whether style divergence is allowed, style scheduling coefficients, and a Seed sequence. This control packet, along with the prompt word, is passed as input to the image generation subsystem. Within the image generation module, the numerical fields of the control packet are decoded level by level and mapped to subcomponents such as the sampler, U-Net control path, and rendering formatter. Within the U-Net layer, communication between the control path and the backbone network is achieved through Zero-Conv connections. The location and strength of the injected control signal are dynamically determined by the real-time parameters in the control packet, forming a generation control flow with acceptance as the central driving force.

[0088] After the images are generated, they are delivered to the front-end in batches for users to browse, adopt, or modify. The front-end event monitoring mechanism then feeds back all the user's operations on the current round of images to the system, enabling the next round of acceptance updates and stage identification, thus closing the adaptive generation loop. The entire structure maintains the architectural features of upstream and downstream decoupling, centralized control of data status, and clear parameter translation flow in system design, supporting the complete closed loop of asynchronous state drive, batch image generation, and behavioral response in multi-user, multi-design task concurrent scenarios. This structure not only has clear hierarchical logic and communication channel division, but also provides an engineering foundation for the scalability and module parallelism of the system's subsequent deployment in a distributed architecture.

[0089] Alternative Solution 1: Use a machine learning classification model based on interactive behavior characteristics to model designer acceptance, replacing the existing weighted scoring method. Specifically, the system no longer directly maps acceptance increases or decreases to single events. Instead, it constructs a structured feature vector from multiple user behavior data from a recent period (e.g., the last five rounds of interaction) and inputs it into a pre-trained lightweight model for discriminative output. Feature dimensions include, but are not limited to, image adoption rate (number of adoptions in the past N rounds / total number of candidate images), average number of revisions, click-to-rejection ratio, average dwell time per round, and interaction cadence (number of operations per unit time). The model can be implemented using XGBoost or a shallow neural network, and the output is an acceptance level (e.g., high, medium, and low) or a normalized confidence score, which can be mapped to the generation control module via soft labels.

[0090] Alternative solution 2: Instead of using the CFG Scale parameter to adjust the image divergence in the image generation control mechanism, a guidance strategy based on the latent space perturbation amplitude control is adopted to achieve a similar effect. The specific method is to introduce a set of adjustable style perturbation vectors δ in the process of generating the StableDiffusion model. z , which is the vector in the latent space with the main image latent variable z t Superposition forms a synthetic latent variable z′ t=z t +α·δ z . Where δ z is the perturbation vector sampled from the style distribution or generated by the style transformation network, α is the perturbation intensity coefficient, which is obtained by mapping the acceptance T. For example:

[0091]

[0092] When the acceptance factor is high, α is large, introducing stronger style jumps into the image generation process, resulting in more creative and uncertain outputs. When the acceptance factor is low, α approaches 0, and the model behavior returns to a stable generation state. This solution does not rely on the CFG control path and can be applied to various diffusion architectures. It is particularly suitable for variant models with unstable CFG convergence or limited CFG strength to control style, while also having greater internal model compatibility.

[0093] This invention discloses a method and system for intelligent clothing pattern generation based on designer acceptance. This approach aims to address the problem that existing AIGC clothing image generation methods are unable to perceive and adapt to changes in designer acceptance, making targeted adjustments and adaptations, resulting in results that deviate from design preferences and severely limiting creative efficiency. The system collects real-time multi-dimensional behavioral feedback from designers on AI-generated clothing designs (including adoption, modification, rejection, saving, and dwell time), establishes a lightweight heuristic acceptance scoring model, and dynamically quantifies the designer's acceptance of the system-generated results. Combining information from different stages of the design process, the system maps acceptance and stage labels to key control parameters of the generation model, enabling diversified output adjustments based on creative progress. Based on an improved Stable Diffusion generation engine, the system employs an architecture that combines a frozen base network with trainable replicas. Dynamic control signals are injected through zero-convolutional layers to flexibly adjust the style complexity, detail richness, and fidelity of the generated images, supporting multi-level design expressions from inspirational sketches to high-fidelity renderings. This method effectively improves the interactive efficiency and personalized adaptation capabilities of AI-assisted design, providing the clothing design industry with an intelligent, dynamic, and reliable assisted creation solution.

[0094] The above are merely preferred embodiments of the present application, but the scope of protection of the present application is not limited thereto. Any changes or substitutions that can be easily conceived by a person skilled in the art within the technical scope disclosed in this application should be included in the scope of protection of the present application. Therefore, the scope of protection of the present application should be based on the scope of protection of the claims.

Claims

1. A method for generating intelligent clothing patterns based on designer acceptance, characterized in that: include: Real-time collection of designer interaction data on AI-generated clothing images; Calculating a dynamic acceptance value based on the type and duration of the interaction behavior data; mapping the acceptance value and the current design stage label to control parameters of an image generation model; Garment images are generated via a hybrid architecture consisting of a frozen backbone network and a trainable control path, where the control signal is injected into the backbone network via zero-initialized convolutional layers.

2. The method for generating intelligent clothing patterns based on designer acceptance according to claim 1, wherein: The interactive behavior data includes the designer's adoption, evolution, save, and rejection operations on the generated image, as well as the image hovering duration; The process of calculating the dynamic acceptance value includes: assigning a first positive weight to the adoption operation; assigning a second positive weight to the evolution operation; assigning a third positive weight to the save operation; assigning a negative weight to the rejection operation; and converting the hovering duration through a nonlinear function and then participating in the calculation.

3. The method for generating intelligent clothing patterns based on designer acceptance according to claim 2, wherein: The process of calculating the dynamic acceptance value further includes: Initialize the acceptance to a neutral value of 0.5; Dynamically update the acceptance value based on the behavior weight; The real-time acceptance value is limited to the preset closed interval [0.1, 1.0] and transmitted to the generation module.

4. The method for generating intelligent clothing patterns based on designer acceptance according to claim 1, wherein: The hybrid architecture of the image generation model includes: A frozen pre-trained clothing image generation network, including a text encoder, a latent space encoder, and a U-Net denoising network; A trainable control path that mirrors part of the encoder structure of the U-Net network; A zero-initialized convolutional layer is connected between the output of the control path and the backbone network.

5. The method for generating intelligent clothing patterns based on designer acceptance according to claim 4, wherein: The process of mapping control parameters includes: When acceptance increases, the semantic guidance intensity is reduced to increase creative divergence; When acceptance decreases, the semantic guidance strength is enhanced to ensure output stability; Automatically adjust the style complexity, detail fidelity, and number of generated output images based on design-stage labels.

6. The method for generating intelligent clothing patterns based on designer acceptance according to claim 5, wherein: The design stage labels include five categories: inspiration generation, sketching, material color matching, detail control, and final rendering.

7. The method for generating intelligent clothing patterns based on designer acceptance according to claim 6, wherein: The process of adjusting the output image includes: In the inspiration generation or sketching stage and when the acceptance level is higher than a first threshold, multiple concept images with divergent compositions are output; During the inspiration generation or sketch drafting stage and when the acceptance level is lower than the second threshold, a small number of reference sketches with clear structures are output; In the detail control or final rendering stage and when the acceptance level is higher than a first threshold, outputting a high-fidelity image; In the detail control or final rendering stage and when the acceptance level is lower than a second threshold, a local close-up image is output.

8. The method for generating intelligent clothing patterns based on designer acceptance according to claim 4, wherein: The training process of the trainable control path includes: Randomly sample acceptance values ​​and design-stage labels in the training batch; Add the control signal to the frozen network through residual injection; Minimize the noise prediction error and jointly optimize the perceptual loss and style preservation loss.

9. A system for generating intelligent clothing patterns based on designer acceptance according to any one of claims 1 to 8, characterized in that: include: An acceptance calculation module is used to collect in real time the designer's interactive behavior data on the AI-generated clothing images and calculate a dynamic acceptance value based on the type and duration of the interactive behavior data; a control parameter mapping module, configured to map the acceptance value and the current design stage label to control parameters of an image generation model; The clothing image generation module is used to generate a clothing image according to the control parameters, wherein the control signal is injected into the backbone network through the zero-initialized convolution layer.

Images