o ۷i@sddlZddlZddlmZddlmZddlmZmZddl m Z ddl m Z dd l mZmZmZmZdd lmZmZmZd d l mZe eZGd ddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZ GdddeZ!Gddde!Z"Gdd d e!Z#Gd!d"d"e!Z$Gd#d$d$e!Z%Gd%d&d&e!Z&Gd'd(d(e!Z'Gd)d*d*e!Z(dS)+N) FrozenDict)ClassifierFreeGuidance)QwenImageControlNetModelQwenImageTransformer2DModel)FlowMatchEulerDiscreteScheduler)logging) BlockStateLoopSequentialPipelineBlocksModularPipelineBlocks PipelineState) ComponentSpec InputParam OutputParam)QwenImageModularPipelinec @\eZdZdZedefddZedeefddZ e de de d ed e jfd d Zd S)QwenImageLoopBeforeDenoiser qwenimagereturncC dSNzstep within the denoising loop that prepares the latent input for the denoiser. This block should be used to compose the `sub_blocks` attribute of a `LoopSequentialPipelineBlocks` object (e.g. `QwenImageDenoiseLoopWrapper`)selfrrc/home/ubuntu/vllm_env/lib/python3.10/site-packages/diffusers/modular_pipelines/qwenimage/denoise.py description(z'QwenImageLoopBeforeDenoiser.descriptioncCstddtjddgS)NlatentsT^The initial latents to use for the denoising process. Can be generated in prepare_latent step.namerequired type_hintr)rtorchTensorrrrrinputs0sz"QwenImageLoopBeforeDenoiser.inputs components block_stateitcCs.||jjd|jj|_|j|_||fS)Nr)expandrshapetodtypetimesteplatent_model_inputrr(r)r*r+rrr__call__;sz$QwenImageLoopBeforeDenoiser.__call__N__name__ __module__ __qualname__ model_namepropertystrrlistrr'r%no_gradrr intr&r3rrrrr%s "rc @r)QwenImageEditLoopBeforeDenoiserqwenimage-editrcCrrrrrrrrFrz+QwenImageEditLoopBeforeDenoiser.descriptioncCstddtjddtdgS)NrTr r! image_latentsrr%r&templaterrrrr'Nsz&QwenImageEditLoopBeforeDenoiser.inputsr(r)r*r+cCs>tj|j|jgdd|_||jjd|jj|_ ||fS)Nr)dimr) r%catrr@r1r,r-r.r/r0r2rrrr3Zsz(QwenImageEditLoopBeforeDenoiser.__call__Nr4rrrrr>Cs "r>c @speZdZdZedeefddZedefddZ edee fddZ e d ed ed ed efd dZdS)%QwenImageLoopBeforeDenoiserControlNetrrcC"tdttddiddtdtgS)Nguiderguidance_scale@ from_configconfigdefault_creation_method controlnet)rrrrrrrrexpected_componentsf z9QwenImageLoopBeforeDenoiserControlNet.expected_componentscCr)Nzstep within the denoising loop that runs the controlnet before the denoiser. This block should be used to compose the `sub_blocks` attribute of a `LoopSequentialPipelineBlocks` object (e.g. `QwenImageDenoiseLoopWrapper`)rrrrrrrrz1QwenImageLoopBeforeDenoiserControlNet.descriptioncCs2tddtjddtjdddtddttd d gS) Ncontrol_image_latentsTzgThe control image to use for the denoising process. Can be generated in prepare_controlnet_inputs step.r#r$rcontrolnet_conditioning_scalez*updated in prepare_controlnet_inputs step.)notecontrolnet_keepzOThe controlnet keep values. Can be generated in prepare_controlnet_inputs step.r!)rr%r&rBr;floatrrrrr'zs z,QwenImageLoopBeforeDenoiserControlNet.inputsr(r)r*r+c Cst|j|trddt|j|j|D|_n|j}t|tr$|d}||j||_|j|j|j|j|j d|j |j |j dd}||j d<||fS)NcSsg|]\}}||qSrr).0csrrr s zBQwenImageLoopBeforeDenoiserControlNet.__call__..rF) hidden_statescontrolnet_condconditioning_scaler0 img_shapesencoder_hidden_statesencoder_hidden_states_mask return_dictcontrolnet_block_samples) isinstancerUr;ziprS cond_scalerNr1rQr0r_ prompt_embedsprompt_embeds_maskadditional_cond_kwargs)rr(r)r*r+controlnet_cond_scalercrrrr3s(   z.QwenImageLoopBeforeDenoiserControlNet.__call__N)r5r6r7r8r9r;rrOr:rrr'r%r<rr r=r3rrrrrEcs  rEc @reZdZdZedefddZedeefddZ edee fddZ e d ed ed ed e jfd dZdS)QwenImageLoopDenoiserrrcCrNzstep within the denoising loop that denoise the latent input for the denoiser. This block should be used to compose the `sub_blocks` attribute of a `LoopSequentialPipelineBlocks` object (e.g. `QwenImageDenoiseLoopWrapper`)rrrrrrrz!QwenImageLoopDenoiser.descriptioncCrFNrGrHrIrJrK transformerrrrrrrrrrOrPz)QwenImageLoopDenoiser.expected_componentsc C.tdtdtddttttfddgS)Nattention_kwargsdenoiser_input_fieldsr_TzhThe shape of the image latents for RoPE calculation. can be generated in prepare_additional_inputs step.rRrrBr;tupler=rrrrr'zQwenImageLoopDenoiser.inputsr(r)r*r+csXt|ddt|ddft|ddt|ddfd}tt|jjj}i}|j D]\}} ||vr<||vr<| ||<q,|j ||j j ||j|d|j |} | D]3|j |jfdd|D} |jd|j|jd |jd d | |j d _|j |jqU| | } tj| jd dd} tj| jd dd}| j| ||_||fS)Nrgnegative_prompt_embedsrhnegative_prompt_embeds_maskr`rastepnum_inference_stepsr0ci|]}|t|qSrgetattrrW input_nameguider_state_batchrr z2QwenImageLoopDenoiser.__call__..r[Fr\r0rrrbrTrCkeepdimr)rsetinspect signatureroforward parameterskeysrsitemsriupdaterG set_stater|prepare_inputsprepare_modelsr1r0rr noise_predcleanup_modelsr%norm pred_condpred)rr(r)r*r+ guider_inputstransformer_argsri field_name field_value guider_state cond_kwargs guider_outputpred_cond_norm pred_normrrrr3sJ        zQwenImageLoopDenoiser.__call__Nr5r6r7r8r9r:rr;rrOrr'r%r<rr r=r&r3rrrrrl  "rlc @rk)QwenImageEditLoopDenoiserr?rcCrrmrrrrrrrz%QwenImageEditLoopDenoiser.descriptioncCrFrnrprrrrrO rPz-QwenImageEditLoopDenoiser.expected_componentsc Crq)Nrrrsr_TzhThe shape of the image latents for RoPE calculation. Can be generated in prepare_additional_inputs step.rRrtrrrrr'rvz QwenImageEditLoopDenoiser.inputsr(r)r*r+cst|ddt|ddft|ddt|ddfd}tt|jjj}i}|j D]\}} ||vr<||vr<| ||<q,|j ||j j ||j|d|j |} | D]3|j |jfdd|D} |jd|j|jd |jd d | |j d _|j |jqU| | } | jddd|jd f} | jddd|jd f}tj|ddd}tj| ddd}| |||_||fS)Nrgrwrhrxryrzcr}rr~rrrrr=rz6QwenImageEditLoopDenoiser.__call__..r[FrrrrTrr)rrrrrorrrrsrrirrGrr|rrr1r0rrrrrrsizerr%r)rr(r)r*r+rrrirrrrrrrrrrrrr3$sN        z"QwenImageEditLoopDenoiser.__call__Nrrrrrrrrc @rk)QwenImageLoopAfterDenoiserrrcCr)Nzstep within the denoising loop that updates the latents. This block should be used to compose the `sub_blocks` attribute of a `LoopSequentialPipelineBlocks` object (e.g. `QwenImageDenoiseLoopWrapper`)rrrrrr\rz&QwenImageLoopAfterDenoiser.descriptioncC tdtgSN schedulerrrrrrrrOdz.QwenImageLoopAfterDenoiser.expected_componentscC tdgSNrrrBrrrrintermediate_outputsjrz/QwenImageLoopAfterDenoiser.intermediate_outputsr(r)r*r+cCsT|jj}|jj|j||jddd|_|jj|kr&tjjr&|j ||_||fS)NF)rbr) rr/rr{rr%backendsmps is_availabler.)rr(r)r*r+ latents_dtyperrrr3ps  z#QwenImageLoopAfterDenoiser.__call__N)r5r6r7r8r9r:rr;rrOrrr%r<rr r=r&r3rrrrrYs"rc @rk)!QwenImageLoopAfterDenoiserInpaintrrcCr)Nzstep within the denoising loop that updates the latents using mask and image_latents for inpainting. This block should be used to compose the `sub_blocks` attribute of a `LoopSequentialPipelineBlocks` object (e.g. `QwenImageDenoiseLoopWrapper`)rrrrrrrz-QwenImageLoopAfterDenoiserInpaint.descriptioncCs,tddtjddtdtddtjddgS)NmaskTz]The mask to use for the inpainting process. Can be generated in inpaint prepare latents step.rRr@ initial_noisezfThe initial noise to use for the inpainting process. Can be generated in inpaint prepare latents step.rArrrrr'sz(QwenImageLoopAfterDenoiserInpaint.inputscCrrrrrrrrrz6QwenImageLoopAfterDenoiserInpaint.intermediate_outputsr(r)r*r+cCsp|j|_|t|jdkr%|j|d|_|j|jt|jg|j |_d|j |j|j |j |_ ||fS)Nr) r@init_latents_properlen timestepsnoise_timestepr scale_noiser%tensorrrrr2rrrr3s z*QwenImageLoopAfterDenoiserInpaint.__call__N)r5r6r7r8r9r:rr;rr'rrr%r<rr r=r&r3rrrrrs"rc@sleZdZdZedefddZedeefddZ edee fddZ e d ed edefd d Zd S)QwenImageDenoiseLoopWrapperrrcCr)NzPipeline block that iteratively denoise the latents over `timesteps`. The specific steps with each iteration can be customized with `sub_blocks` attributesrrrrrrrz'QwenImageDenoiseLoopWrapper.descriptioncCrrrrrrrloop_expected_componentsrz4QwenImageDenoiseLoopWrapper.loop_expected_componentscCs tddtjddtjdddgS)NrTzWThe timesteps to use for the denoising process. Can be generated in set_timesteps step.r!r|)r#rArrrr loop_inputss z'QwenImageDenoiseLoopWrapper.loop_inputsr(statecCs||}tt|j|j|jjd|_i|_|j |jd;}t |jD]-\}}|j ||||d\}}|t|jdksN|d|jkrR|d|jjdkrR| q%Wdn1s]wY| ||||fS)Nr)total)r*r+r)get_block_statemaxrrr|rordernum_warmup_stepsri progress_bar enumerate loop_steprset_block_state)rr(rr)rr*r+rrrr3s " z$QwenImageDenoiseLoopWrapper.__call__N)r5r6r7r8r9r:rr;rrrrr%r<rr r3rrrrrs rc@8eZdZdZdZeeegZgdZ e de fddZ dS)QwenImageDenoiseStepa Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports text2image and image2image tasks for QwenImage. Components: guider (`ClassifierFreeGuidance`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. can be generated in prepare_additional_inputs step. Outputs: latents (`Tensor`): Denoised latents. rbefore_denoiserdenoiserafter_denoiserrcCr)NaeDenoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports text2image and image2image tasks for QwenImage.rrrrrrrz QwenImageDenoiseStep.descriptionN) r5r6r7__doc__r8rrlr block_classes block_namesr9r:rrrrrrs rc@:eZdZdZdZeeeegZ gdZ e de fddZ dS)QwenImageInpaintDenoiseStepad Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` - `QwenImageLoopAfterDenoiserInpaint` This block supports inpainting tasks for QwenImage. Components: guider (`ClassifierFreeGuidance`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. can be generated in prepare_additional_inputs step. mask (`Tensor`): The mask to use for the inpainting process. Can be generated in inpaint prepare latents step. image_latents (`Tensor`): image latents used to guide the image generation. Can be generated from vae_encoder step. initial_noise (`Tensor`): The initial noise to use for the inpainting process. Can be generated in inpaint prepare latents step. Outputs: latents (`Tensor`): Denoised latents. rrrrafter_denoiser_inpaintrcCr)Na~Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` - `QwenImageLoopAfterDenoiserInpaint` This block supports inpainting tasks for QwenImage.rrrrrr^rz'QwenImageInpaintDenoiseStep.descriptionN)r5r6r7rr8rrlrrrrr9r:rrrrrr-'rc@r)QwenImageControlNetDenoiseStepa Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopBeforeDenoiserControlNet` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports text2img/img2img tasks with controlnet for QwenImage. Components: guider (`ClassifierFreeGuidance`) controlnet (`QwenImageControlNetModel`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. control_image_latents (`Tensor`): The control image to use for the denoising process. Can be generated in prepare_controlnet_inputs step. controlnet_conditioning_scale (`float`, *optional*, defaults to 1.0): Scale for ControlNet conditioning. (updated in prepare_controlnet_inputs step.) controlnet_keep (`list`): The controlnet keep values. Can be generated in prepare_controlnet_inputs step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. can be generated in prepare_additional_inputs step. Outputs: latents (`Tensor`): Denoised latents. r)rbefore_denoiser_controlnetrrrcCr)NaDenoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopBeforeDenoiserControlNet` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports text2img/img2img tasks with controlnet for QwenImage.rrrrrrrz*QwenImageControlNetDenoiseStep.descriptionN)r5r6r7rr8rrErlrrrr9r:rrrrrrnrrc@s<eZdZdZdZeeeee gZ gdZ e de fddZdS)%QwenImageInpaintControlNetDenoiseStepa Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopBeforeDenoiserControlNet` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` - `QwenImageLoopAfterDenoiserInpaint` This block supports inpainting tasks with controlnet for QwenImage. Components: guider (`ClassifierFreeGuidance`) controlnet (`QwenImageControlNetModel`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. control_image_latents (`Tensor`): The control image to use for the denoising process. Can be generated in prepare_controlnet_inputs step. controlnet_conditioning_scale (`float`, *optional*, defaults to 1.0): Scale for ControlNet conditioning. (updated in prepare_controlnet_inputs step.) controlnet_keep (`list`): The controlnet keep values. Can be generated in prepare_controlnet_inputs step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. can be generated in prepare_additional_inputs step. mask (`Tensor`): The mask to use for the inpainting process. Can be generated in inpaint prepare latents step. image_latents (`Tensor`): image latents used to guide the image generation. Can be generated from vae_encoder step. initial_noise (`Tensor`): The initial noise to use for the inpainting process. Can be generated in inpaint prepare latents step. Outputs: latents (`Tensor`): Denoised latents. r)rrrrrrcCr)NaDenoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageLoopBeforeDenoiser` - `QwenImageLoopBeforeDenoiserControlNet` - `QwenImageLoopDenoiser` - `QwenImageLoopAfterDenoiser` - `QwenImageLoopAfterDenoiserInpaint` This block supports inpainting tasks with controlnet for QwenImage.rrrrrrrz1QwenImageInpaintControlNetDenoiseStep.descriptionN)r5r6r7rr8rrErlrrrrr9r:rrrrrrs.rc@r)QwenImageEditDenoiseStepa Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageEditLoopBeforeDenoiser` - `QwenImageEditLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports QwenImage Edit. Components: guider (`ClassifierFreeGuidance`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. image_latents (`Tensor`): image latents used to guide the image generation. Can be generated from vae_encoder step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. Can be generated in prepare_additional_inputs step. Outputs: latents (`Tensor`): Denoised latents. r?rrcCr)NaODenoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageEditLoopBeforeDenoiser` - `QwenImageEditLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports QwenImage Edit.rrrrrr*rz$QwenImageEditDenoiseStep.descriptionN r5r6r7rr8r>rrrrr9r:rrrrrr"rc@r)QwenImageEditInpaintDenoiseStepaq Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageEditLoopBeforeDenoiser` - `QwenImageEditLoopDenoiser` - `QwenImageLoopAfterDenoiser` - `QwenImageLoopAfterDenoiserInpaint` This block supports inpainting tasks for QwenImage Edit. Components: guider (`ClassifierFreeGuidance`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. image_latents (`Tensor`): image latents used to guide the image generation. Can be generated from vae_encoder step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. Can be generated in prepare_additional_inputs step. mask (`Tensor`): The mask to use for the inpainting process. Can be generated in inpaint prepare latents step. initial_noise (`Tensor`): The initial noise to use for the inpainting process. Can be generated in inpaint prepare latents step. Outputs: latents (`Tensor`): Denoised latents. r?rrcCr)NaDenoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageEditLoopBeforeDenoiser` - `QwenImageEditLoopDenoiser` - `QwenImageLoopAfterDenoiser` - `QwenImageLoopAfterDenoiserInpaint` This block supports inpainting tasks for QwenImage Edit.rrrrrrjrz+QwenImageEditInpaintDenoiseStep.descriptionN)r5r6r7rr8r>rrrrrr9r:rrrrrr9rrc@r)QwenImageLayeredDenoiseStepa Denoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageEditLoopBeforeDenoiser` - `QwenImageEditLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports QwenImage Layered. Components: guider (`ClassifierFreeGuidance`) transformer (`QwenImageTransformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) Inputs: timesteps (`Tensor`): The timesteps to use for the denoising process. Can be generated in set_timesteps step. num_inference_steps (`int`): The number of denoising steps. latents (`Tensor`): The initial latents to use for the denoising process. Can be generated in prepare_latent step. image_latents (`Tensor`): image latents used to guide the image generation. Can be generated from vae_encoder step. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. **denoiser_input_fields (`None`, *optional*): conditional model inputs for the denoiser: e.g. prompt_embeds, negative_prompt_embeds, etc. img_shapes (`list`): The shape of the image latents for RoPE calculation. Can be generated in prepare_additional_inputs step. Outputs: latents (`Tensor`): Denoised latents. zqwenimage-layeredrrcCr)NaRDenoise step that iteratively denoise the latents. Its loop logic is defined in `QwenImageDenoiseLoopWrapper.__call__` method At each iteration, it runs blocks defined in `sub_blocks` sequencially: - `QwenImageEditLoopBeforeDenoiser` - `QwenImageEditLoopDenoiser` - `QwenImageLoopAfterDenoiser` This block supports QwenImage Layered.rrrrrrrz'QwenImageLayeredDenoiseStep.descriptionNrrrrrrzrr))rr%configuration_utilsrguidersrmodelsrr schedulersrutilsrmodular_pipeliner r r r modular_pipeline_utilsrrrr get_loggerr5loggerrr>rErlrrrrrrrrrrrrrrrs4       HUY)6<9AAP:A