+h1MSSKJr SSKJrJrJrJr SSKrSSKJ s J r SSKJ r SSK J r Jr SSKJr SSKJr SS KJr SS KJr S S KJrJrJrJrJr S S KJr S SKJ r SSK!J"r"J#r#J$r$ \"SS\55r%"SS\\ 5r&g)) dataclass)DictOptionalTupleUnionN)nn) ConfigMixinregister_to_config)ConsistencyDecoderScheduler) BaseOutput)apply_forward_hook) randn_tensor)ADDED_KV_ATTENTION_PROCESSORSCROSS_ATTENTION_PROCESSORSAttentionProcessorAttnAddedKVProcessor AttnProcessor) ModelMixin) UNet2DModel) DecoderOutputDiagonalGaussianDistributionEncoderc$\rSrSr%SrS\S'Srg)ConsistencyDecoderVAEOutput&a Output of encoding method. Args: latent_dist (`DiagonalGaussianDistribution`): Encoded outputs of `Encoder` represented as the mean and logvar of `DiagonalGaussianDistribution`. `DiagonalGaussianDistribution` allows for sampling latents from the distribution. r latent_distN)__name__ __module__ __qualname____firstlineno____doc____annotations____static_attributes__r o/home/james-whalen/.local/lib/python3.13/site-packages/diffusers/models/autoencoders/consistency_decoder_vae.pyrr&s0/r(rc4^\rSrSrSrSr\S9S\S\S\S\ S\ \S 4S \ S \ \ S 4S \S \S\S\S\ S\ \S 4S\ \ S 4S\S\S\S\S\S\S\S\ S\ S\ \ S 440U4Sjjj5r S:S\ 4Sjjr S rS!rS"r\S#\\ \44S$j5rS%\\\\ \444S&jrS'r\S:S(\R4S)\ S#\\\ \44S*jj5r\S;S+\R4S,\\R>S)\ S-\S#\\ \ \R444 S.jj5r!S/\R4S0\R4S1\S#\R44S2jr"S/\R4S0\R4S1\S#\R44S3jr#S:S(\R4S)\ S#\\\ 44S4jjr$SS#\\ \ \R444 S7jjr%S8r&U=r'$)=ConsistencyDecoderVAE4a The consistency decoder used with DALL-E 3. Examples: ```py >>> import torch >>> from diffusers import StableDiffusionPipeline, ConsistencyDecoderVAE >>> vae = ConsistencyDecoderVAE.from_pretrained("openai/consistency-decoder", torch_dtype=torch.float16) >>> pipe = StableDiffusionPipeline.from_pretrained( ... "stable-diffusion-v1-5/stable-diffusion-v1-5", vae=vae, torch_dtype=torch.float16 ... ).to("cuda") >>> image = pipe("horse", generator=torch.manual_seed(0)).images[0] >>> image ``` Fscaling_factorlatent_channels sample_sizeencoder_act_fnencoder_block_out_channels.encoder_double_zencoder_down_block_typesencoder_in_channelsencoder_layers_per_blockencoder_norm_num_groupsencoder_out_channelsdecoder_add_attentiondecoder_block_out_channelsdecoder_down_block_typesdecoder_downsample_paddingdecoder_in_channelsdecoder_layers_per_blockdecoder_norm_epsdecoder_norm_num_groupsdecoder_num_train_timestepsdecoder_out_channelsdecoder_resnet_time_scale_shiftdecoder_time_embedding_typedecoder_up_block_typesch>[TU]5 [UUUUUU U U S9Ul[ U U UUUUUUUUUUUS9 Ul[ 5UlURUS9 URSS9 URS[R"/SQ5SSS2SS4SS9 URS [R"/S Q5SSS2SS4SS9 [R"S U-S U-S 5UlSUlSUlUR"R$Ul[)UR"R$[*[,45(aUR"R$S OUR"R$n[/US [1UR"R25S - -- 5UlSUlg)N)act_fnblock_out_channelsdouble_zdown_block_types in_channelslayers_per_blocknorm_num_groups out_channels) add_attentionrGrIdownsample_paddingrJrKnorm_epsrLnum_train_timestepsrMresnet_time_scale_shifttime_embedding_typeup_block_types)rGF) force_upcastmeans)gg:?gyD?glL?g N3^) persistentstds)g4?gn=?gr ^?gr` ?rrrg?)super__init__rencoderr decoder_unetr decoder_schedulerr register_buffertorchtensorrConv2d quant_conv use_slicing use_tilingconfigr/tile_sample_min_size isinstancelisttupleintlenrGtile_latent_min_sizetile_overlap_factor)selfr-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrD __class__s r)rZConsistencyDecoderVAE.__init__IsV !9%5+53-   (/959+5%3 ;-$C ;1 "=!> 3MN U3   LLI J4QRTXZ^K^ _   ELL!OPQUWXZ^`dQderw  ))A$7_9LaP %)KK$;$;!$++11D%=AA KK # #A &((  %( qSA_A_=`cd=d7e(f$g!#' r(rdcXlg)z Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow processing larger images. N)rd)rnrds r) enable_tiling#ConsistencyDecoderVAE.enable_tilings %r(c&URS5 g)z Disable tiled VAE decoding. If `enable_tiling` was previously enabled, this method will go back to computing decoding in one step. FN)rrrns r)disable_tiling$ConsistencyDecoderVAE.disable_tilings 5!r(cSUlg)z Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to compute decoding in several steps. This is useful to save some memory and allow larger batch sizes. TNrcrus r)enable_slicing$ConsistencyDecoderVAE.enable_slicings  r(cSUlg)z Disable sliced VAE decoding. If `enable_slicing` was previously enabled, this method will go back to computing decoding in one step. FNryrus r)disable_slicing%ConsistencyDecoderVAE.disable_slicings !r(returnc^0nS[S[RRS[[[ 44U4SjjmUR 5Hup#T"X#U5 M U$)z Returns: `dict` of attention processors: A dictionary containing all attention processors used in the model with indexed by its weight name. namemodule processorsc>[US5(aUR5X S3'UR5Hup4T"USU3XB5 M U$)N get_processor .processor.)hasattrrnamed_children)rrrsub_namechildfn_recursive_add_processorss r)rJConsistencyDecoderVAE.attn_processors..fn_recursive_add_processorssZv//282F2F2H V:./#)#8#8#:+tfAhZ,@%T$; r()strr_rModulerrr)rnrrrrs @r)attn_processors%ConsistencyDecoderVAE.attn_processorssb  c 588?? X\]`bt]tXu !//1LD 'j A2r( processorc d^[URR55n[U[5(a-[U5U:wa[ S[U5SUSUS35eS[ S[RR4U4SjjmUR5Hup4T"X4U5 M g) a Sets the attention processor to use to compute attention. Parameters: processor (`dict` of `AttentionProcessor` or only `AttentionProcessor`): The instantiated processor class or a dictionary of processor classes that will be set as the processor for **all** `Attention` layers. If `processor` is a dict, the key needs to define the path to the corresponding cross attention processor. This is strongly recommended when setting trainable attention processors. z>A dict of processors was passed, but the number of processors z0 does not match the number of attention layers: z. Please make sure to pass z processor classes.rrc >[US5(aJ[U[5(dURU5 O#URUR US355 UR 5Hup4T"USU3XB5 M g)N set_processorrr)rrgdictrpopr)rrrrrfn_recursive_attn_processors r)rMConsistencyDecoderVAE.set_attn_processor..fn_recursive_attn_processorssv//!)T22((3(($z7J)KL#)#8#8#:+tfAhZ,@%S$;r(N) rkrkeysrgr ValueErrorrr_rrr)rnrcountrrrs @r)set_attn_processor(ConsistencyDecoderVAE.set_attn_processorsD((--/0 i & &3y>U+BPQTU^Q_P`a005w6QRWQXXkm   Tc T588?? T!//1LD 'i @2r(c ~[SURR555(a [5nOr[SURR555(a [ 5nO8[ S[ [URR55535eURU5 g)zU Disables custom attention processors and sets the default attention implementation. c3F# UHoR[;v M g7fN)ror.0procs r) CConsistencyDecoderVAE.set_default_attn_processor.. siKh4~~!>>Kh!c3F# UHoR[;v M g7fr)rorrs r)rrshJg$#==JgrzOCannot call `set_default_attn_processor` when attention processors are of type N) allrvaluesrrrnextiterr)rnrs r)set_default_attn_processor0ConsistencyDecoderVAE.set_default_attn_processors i4K_K_KfKfKhi i i,.I h$J^J^JeJeJgh h h%IabfgklpmAmAmHmHmJhKcLbMN   *r(x return_dictcUR(aIURSUR:dURSUR:aURXS9$UR(aYURSS:aFUR S5Vs/sHo0R U5PM nn[R"U5nOUR U5nURU5n[U5nU(dU4$[US9$s snf)a Encode a batch of images into latents. Args: x (`torch.Tensor`): Input batch of images. return_dict (`bool`, *optional*, defaults to `True`): Whether to return a [`~models.autoencoders.consistency_decoder_vae.ConsistencyDecoderVAEOutput`] instead of a plain tuple. Returns: The latent representations of the encoded images. If `return_dict` is True, a [`~models.autoencoders.consistency_decoder_vae.ConsistencyDecoderVAEOutput`] is returned, otherwise a plain `tuple` is returned. )rrrr) rdshaperf tiled_encodercsplitr[r_catrbrr)rnrrx_sliceencoded_sliceshmoments posteriors r)encodeConsistencyDecoderVAE.encodes$ ?? d.G.G G177SU;Y]YrYrKr$$Q$@ @    QCD771:N:ll73:NN .)A QA//!$09 < *yAAOsDz generatornum_inference_stepscXRR-UR- UR- nS[ URR 5S- -n[ R"USUS9nURupgpURRX@RS9 URR[USX4X!RURS9-n URRHn [ R""URR%X5U/SS9n UR'X5R(S S 2S S2S S 2S S 24n URR+XX5R,nUn M U nU(dU4$[/US 9$) a Decodes the input latent vector `z` using the consistency decoder VAE model. Args: z (torch.Tensor): The input latent vector. generator (Optional[torch.Generator]): The random number generator. Default is None. return_dict (bool): Whether to return the output as a dictionary. Default is True. num_inference_steps (int): The number of inference steps. Default is 2. Returns: Union[DecoderOutput, Tuple[torch.Tensor]]: The decoded output. rrnearest)mode scale_factor)devicer )rdtyperdimNsample)rer-rVrXrkrGF interpolaterr] set_timestepsrinit_noise_sigmarr timestepsr_concatscale_model_inputr\rstep prev_sampler)rnrrrrr batch_size_heightwidthx_tt model_input model_outputrx_0s r)decodeConsistencyDecoderVAE.decode:s_*++ +djj 8DII ES!?!?@1DE MM!), G'(ww$ v ,,-@,U$$55 F *iwwWXW_W_9  ''11A,,(>(>(P(PQT(XZ['\bcdK,,[<CCArr1aKPL0055lsVbbKC 2 6MC((r(ab blend_extentc[URSURSU5n[U5H@nUSS2SS2U*U-SS24SXC- - -USS2SS2USS24XC- --USS2SS2USS24'MB U$)Nrrminrrange)rnrrrys r)blend_vConsistencyDecoderVAE.blend_vjs1771:qwwqz<@ |$Aa\MA$5q89QAQ=QRUVWXZ[]^`aWaUbfgfvUwwAaAqjM%r(c[URSURSU5n[U5H@nUSS2SS2SS2U*U-4SXC- - -USS2SS2SS2U4XC- --USS2SS2SS2U4'MB U$)Nr rr)rnrrrrs r)blend_hConsistencyDecoderVAE.blend_hqs1771:qwwqz<@ |$AaA }q'889QAQ=QRUVWXZ[]^`aWaUbfgfvUwwAaAqjM%r(c [URSUR- -5n[URUR-5nURU- n/n[ SUR SU5Hn/n[ SUR SU5H_n USS2SS2XwUR-2XUR-24n UR U 5n URU 5n URU 5 Ma URU5 M /n [U5Hupx/n [U5HbupUS:aURXgS- U X5n U S:aURXS- X5n U RU SS2SS2SU2SU245 Md U R[R"U SS95 M [R"U SS9n [U 5nU(dU4$[US9$)a*Encode a batch of images using a tiled encoder. When this option is enabled, the VAE will split the input tensor into tiles to compute encoding in several steps. This is useful to keep memory use constant regardless of image size. The end result of tiled encoding is different from non-tiled encoding because each tile uses a different encoder. To avoid tiling artifacts, the tiles overlap and are blended together to form a smooth output. You may still see tile-sized changes in the output, but they should be much less noticeable. Args: x (`torch.Tensor`): Input batch of images. return_dict (`bool`, *optional*, defaults to `True`): Whether or not to return a [`~models.autoencoders.consistency_decoder_vae.ConsistencyDecoderVAEOutput`] instead of a plain tuple. Returns: [`~models.autoencoders.consistency_decoder_vae.ConsistencyDecoderVAEOutput`] or `tuple`: If return_dict is True, a [`~models.autoencoders.consistency_decoder_vae.ConsistencyDecoderVAEOutput`] is returned, otherwise a plain `tuple` is returned. rrrr Nrr)rjrfrmrlrrr[rbappend enumeraterrr_rrr)rnrr overlap_sizer row_limitrowsirowjtile result_rows result_rowrrs r)r"ConsistencyDecoderVAE.tiled_encodews(444Dq5<<U AKDq5<<E DGD!!$q!ZiZ)'C"DE*   uyy; <&))KQ/09 < *yAAr(rsample_posteriorcUnURU5RnU(aURUS9nOUR5nUR XtS9RnU(dU4$[ US9$)a' Args: sample (`torch.Tensor`): Input sample. sample_posterior (`bool`, *optional*, defaults to `False`): Whether to sample from the posterior. return_dict (`bool`, *optional*, defaults to `True`): Whether or not to return a [`DecoderOutput`] instead of a plain tuple. generator (`torch.Generator`, *optional*, defaults to `None`): Generator to use for sampling. Returns: [`DecoderOutput`] or `tuple`: If return_dict is True, a [`DecoderOutput`] is returned, otherwise a plain `tuple` is returned. )rr)rrrrrr) rnrrrrrrrdecs r)forwardConsistencyDecoderVAE.forwardsi* KKN..   9 5A Akk!k1886MC((r() r]r\r[rbrlrmrfrcrd)g{P? silu)rT)DownEncoderBlock2Drrrr rrrF)i@ir)ResnetDownsampleBlock2Drrrrr gh㈵>rr scale_shiftlearned)ResnetUpsampleBlock2Dr r r )T)NTr)FTN)(r!r"r#r$r%_supports_group_offloadingr floatrjrrboolrZrrrvrzr}propertyrrrrrrrr_Tensorrrrr Generatorrrrrrrr' __classcell__)ros@r)r+r+4s$"'!( $6J!%5 $%()')$%&+6L5 +,#$()"'')+/$%/<+43 G^(^(^( ^(  ^( %*#s(O ^(^(#(S/^(!^(#&^( "%!^(""#^($ $%^(&%*#s(O'^((#(S/)^(4%(5^(6!7^(8#&9^(: ;^(<"%=^(>&)?^(@"A^(B*-C^(D&)E^(F!&c3hG^(^(B%%" !c+=&=!>0 AE2Dd3PbKbFc2c,d AF +37 B B,0 B *E2N,OO P B BD04 #$ ,) <<,)EOO,,) ,) ! ,) }eELL11 2 ,),)^%,,cell%,,cell 5Bell5B5BOjlqOqIr5Bt"' /3 )  ) ) ) EOO, ) }eELL11 2 ) )r(r+)' dataclassesrtypingrrrrr_torch.nn.functionalr functionalrconfiguration_utilsr r schedulersr utilsr utils.accelerate_utilsrutils.torch_utilsrattention_processorrrrrrmodeling_utilsr unets.unet_2drvaerrrrr+r r(r)r"sn"// B58-('EE  0* 0  0Z)J Z)r(