+ Lja^RIt^RIHt^RIt^RIHt^RIHtHt^RI H t ^RI H t ] P!]4t!RR] 4t!RR ] ]4t!R R ]P$4t!R R ]P$4t!RR]P$4t!RR]P$4t!RR]P$4t!RR]P$4t!RR]P$4tR#)N)Callable) ConfigMixinregister_to_config)logging) ModelMixincaa]tRt^toRtV3RlV3RlltR V3RlRlltR V3RlRllt]V3RlR l4t R t Vt V;t #) MultiAdaptera} MultiAdapter is a wrapper model that contains multiple adapter models and merges their outputs according to user-assigned weighting. This model inherits from [`ModelMixin`]. Check the superclass documentation for common methods such as downloading or saving. Args: adapters (`list[T2IAdapter]`, *optional*, defaults to None): A list of `T2IAdapter` model instances. c.<V^8dQhRS[R,/#)adapters T2IAdapter)list)format __classdict__s"D/app/.local/lib/python3.14/site-packages/diffusers/models/adapter.py __annotate__MultiAdapter.__annotate__)s!?!?l!3!?c`<\\V` 4\V4Vn\ P !V4Vn\V4^8Xd \R4h\V4^8Xd \R4hV^,PpV^,Pp\^\V44FnpW,PV8wgW,PV8wgK3\RV RV RV RW,P RV RW,P 2 4h W n W0n R#) rzExpecting at least one adapterzQFor a single adapter, please use the `T2IAdapter` class instead of `MultiAdapter`zjExpecting all adapters to have the same downscaling behavior, but got: adapters[0].total_downscale_factor=z adapters[0].downscale_factor=z adapter[`z`].total_downscale_factor=z`].downscale_factor=N) superr __init__len num_adapternn ModuleListr ValueErrortotal_downscale_factordownscale_factorrange)selfr $first_adapter_total_downscale_factorfirst_adapter_downscale_factoridx __class__s&& rrMultiAdapter.__init__)s$ lD*,x= h/ x=A => > x=A pq q08{/Q/Q,)1!)E)E&CM*C 448\\=115SS ::^9_`44R3ST #u$>x}?c?c>de #u$89W9W8X Z +'K# >rc<V^8dQhRS[PRS[S[,R,RS[S[P,/#)r xsadapter_weightsNreturn)torchTensorrfloat)rrs"rrrLs<  %,, et9K W[\a\h\hWi rc Vf;\P!^VP, .VP,4pM\P!V4pRp\WVP4F~wrEpV!V4pVf1Tp\ \ V44FpWSV,,W8&K KB\ \ V44F$pW8;;,WWV,,, uu&K& K V#)a Args: xs (`torch.Tensor`): A tensor of shape (batch, channel, height, width) representing input images for multiple adapter models, concatenated along dimension 1(channel dimension). The `channel` dimension should be equal to `num_adapter` * number of channel per image. adapter_weights (`list[float]`, *optional*, defaults to None): A list of floats representing the weights which will be multiplied by each adapter's output before summing them together. If `None`, equal weights will be used for all adapters. Returns: `list[torch.Tensor]`: A list of feature tensors, one per scale, obtained by summing the per-scale features of each adapter weighted by `adapter_weights`. N)r*tensorrzipr rr) r r'r( accume_statexwadapterfeaturesis &&& rforwardMultiAdapter.forwardLs"  "#llA0@0@,@+ADDTDT+TUO#ll?;O  dmmDMA'qzH#' s<01A&'q/&9LO2s8}-A OqA;6O.Erc j<V^8dQhRS[S[P,RS[RS[RS[RS[R,/#)r save_directoryis_main_process save_functionsafe_serializationvariantN)strosPathLikeboolr)rrs"rrrnsQ(@(@bkk)(@(@ (@ ! (@ t (@rc  ^pTpVPF.pVPVVVVVR7V^, pVRV 2,pK0 R#)a Save a model and its configuration file to a specified directory, allowing it to be re-loaded with the `[`~models.adapter.MultiAdapter.from_pretrained`]` class method. Args: save_directory (`str` or `os.PathLike`): The directory where the model will be saved. If the directory does not exist, it will be created. is_main_process (`bool`, optional, defaults=True): Indicates whether current process is the main process or not. Useful for distributed training (e.g., TPUs) and need to call this function on all processes. In this case, set `is_main_process=True` only for the main process to avoid race conditions. save_function (`Callable`): Function used to save the state dictionary. Useful for distributed training (e.g., TPUs) to replace `torch.save` with another method. Can also be configured using`DIFFUSERS_SAVE_MODE` environment variable. safe_serialization (`bool`, optional, defaults=True): If `True`, save the model using `safetensors`. If `False`, save the model with `pickle`. variant (`str`, *optional*): If specified, weights are saved in the format `pytorch_model..bin`. )r:r;r<r=_N)r save_pretrained) r r9r:r;r<r=r#model_path_to_saver3s &&&&&& rrDMultiAdapter.save_pretrainedns[8+}}G  # #" /+#5 $  1HC!3#i!? %rcR<V^8dQhRS[S[P,R,/#)r pretrained_model_pathN)r>r?r@)rrs"rrrs%AAC"++4E4LArc ^p.pTp\PPV4'd@\P!V3/VBpVP V4V^, pVRV 2,pKd\ P\V4 RV R24\V4^8Xd7\R\PPV4 RVR, R24hV!V4#)ag Instantiate a pretrained `MultiAdapter` model from multiple pre-trained adapter models. The model is set in evaluation mode by default using `model.eval()` (Dropout modules are deactivated). To train the model, set it back to training mode using `model.train()`. Warnings: *Weights from XXX not initialized from pretrained model* means that the weights of XXX are not pretrained with the rest of the model. It is up to you to train those weights with a downstream fine-tuning. *Weights from XXX not used in YYY* means that the layer XXX is not used by YYY, so those weights are discarded. Args: pretrained_model_path (`os.PathLike`): A path to a *directory* containing model weights saved using [`~diffusers.models.adapter.MultiAdapter.save_pretrained`], e.g., `./my_model_directory/adapter`. torch_dtype (`torch.dtype`, *optional*): Override the default `torch.dtype` and load the model under this dtype. output_loading_info(`bool`, *optional*, defaults to `False`): Whether or not to also return a dictionary containing missing keys, unexpected keys and error messages. device_map (`str` or `dict[str, int | str | torch.device]`, *optional*): A map that specifies where each submodule should go. It doesn't need to be refined to each parameter/buffer name, once a given module name is inside, every submodule of it will be sent to the same device. To have Accelerate compute the most optimized `device_map` automatically, set `device_map="auto"`. For more information about each option see [designing a device map](https://hf.co/docs/accelerate/main/en/usage_guides/big_modeling#designing-a-device-map). max_memory (`Dict`, *optional*): A dictionary mapping device identifiers to their maximum memory. Default to the maximum memory available for each GPU and the available CPU RAM if unset. low_cpu_mem_usage (`bool`, *optional*, defaults to `True` if torch version >= 1.9.0 else `False`): Speed up model loading by not initializing the weights and only loading the pre-trained weights. This also tries to not use more than 1x model size in CPU memory (including peak memory) while loading the model. This is only supported when torch version >= 1.9.0. If you are using an older version of torch, setting this argument to `True` will raise an error. variant (`str`, *optional*): If specified, load weights from a `variant` file (*e.g.* pytorch_model..bin). `variant` will be ignored when using `from_flax`. use_safetensors (`bool`, *optional*, defaults to `None`): If `None`, the `safetensors` weights will be downloaded if available **and** if`safetensors` library is installed. If `True`, the model will be forcibly loaded from`safetensors` weights. If `False`, `safetensors` is not used. rCz adapters loaded from .zNo T2IAdapters found under z. Expected at least _0) r?pathisdirr from_pretrainedappendloggerinforrdirname)clsrHkwargsr#r model_path_to_loadr3s&&, rrNMultiAdapter.from_pretrainedsZ 3ggmm.// 001CNvNG OOG $ 1HC!61SE!B  s8}o%;S.T-UUijCGkGjHHIJ 8}r)r rrrN)TNTN) __name__ __module__ __qualname____firstlineno____doc__rr6rD classmethodrN__static_attributes____classdictcell__ __classcell__r$rs@@rr r sI !?!?F  D(@(@TAAArr caa]tRt^toRt]^.R O^^R3V3RlV3Rlll4tV3RlRlt]R4t ]R4t R t Vt V;t #) r a A simple ResNet-like model that accepts images containing control signals such as keyposes and depth. The model generates multiple feature maps that are used as additional conditioning in [`UNet2DConditionModel`]. The model's architecture follows the original implementation of [Adapter](https://github.com/TencentARC/T2I-Adapter/blob/686de4681515662c0ac2ffa07bf5dda83af1038a/ldm/modules/encoders/adapter.py#L97) and [AdapterLight](https://github.com/TencentARC/T2I-Adapter/blob/686de4681515662c0ac2ffa07bf5dda83af1038a/ldm/modules/encoders/adapter.py#L235). This model inherits from [`ModelMixin`]. Check the superclass documentation for the common methods, such as downloading or saving. Args: in_channels (`int`, *optional*, defaults to `3`): The number of channels in the adapter's input (*control image*). Set it to 1 if you're using a gray scale image. channels (`list[int]`, *optional*, defaults to `(320, 640, 1280, 1280)`): The number of channels in each downsample block's output hidden state. The `len(block_out_channels)` determines the number of downsample blocks in the adapter. num_res_blocks (`int`, *optional*, defaults to `2`): Number of ResNet blocks in each downsample block. downscale_factor (`int`, *optional*, defaults to `8`): A factor that determines the total downscale factor of the Adapter. adapter_type (`str`, *optional*, defaults to `full_adapter`): Adapter type (`full_adapter` or `full_adapter_xl` or `light_adapter`) to use. full_adapterc H<V^8dQhRS[RS[S[,RS[RS[RS[/#)r in_channelschannelsnum_res_blocksr adapter_type)intrr>)rrs"rrT2IAdapter.__annotate__sAs)     rc<\SV`4VR8Xd\WW44VnR#VR8Xd\ WW44VnR#VR8Xd\ WW44VnR#\ RV R24h)rcfull_adapter_xl light_adapterzUnsupported adapter_type: 'zH'. Choose either 'full_adapter' or 'full_adapter_xl' or 'light_adapter'.N)rr FullAdapterr3 FullAdapterXL LightAdapterr)r rerfrgrrhr$s&&&&&&rrT2IAdapter.__init__sq  > )&{n_DL . .(aDL _ ,' ~`DL-l^<88 rc^<V^8dQhRS[PRS[S[P,/#r r1r)r*r+r)rrs"rrrjs($u||*<rc $VPV4#)a This function processes the input tensor `x` through the adapter model and returns a list of feature tensors, each representing information extracted at a different scale from the input. The length of the list is determined by the number of downsample blocks in the Adapter, as specified by the `channels` and `num_res_blocks` parameters during initialization. Args: x (`torch.Tensor`): The input tensor to process through the adapter model. Returns: `list[torch.Tensor]`: A list of feature tensors, each representing information extracted at a different scale from the input. The length of the list equals the number of downsample blocks in the adapter. r3r r1s&&rr6T2IAdapter.forwards ||Arc.VPP#rW)r3rr s&rr!T2IAdapter.total_downscale_factor!s||222rc BVPPP#)zThe downscale factor applied in the T2I-Adapter's initial pixel unshuffle operation. If an input image's dimensions are not evenly divisible by the downscale_factor then an exception will be raised. )r3 unshufflerrzs&rrT2IAdapter.downscale_factor%s ||%%666rrv@r)rXrYrZr[r\rrr6propertyrrr^r_r`ras@@rr r sk44 !* ,$33777rr cdaa]tRtRtoRt^.RO^^3V3RlV3RllltV3RlRltRtVtV;t #) rni0* See [`T2IAdapter`] for more information. cB<V^8dQhRS[RS[S[,RS[RS[/#r rerfrgrrir)rrs"rrFullAdapter.__annotate__5s=RRRs)R R  Rrc  <\SV`4W^,,p\P!V4Vn\P !W^,^^R7Vn\P!\V^,V^,V4.\^\V44Uu.uF%p\W%^, ,W%,VRR7NK' upO4Vn V^\V4^, ,,Vn R#uupir  kernel_sizepaddingTdownN) rrrPixelUnshuffler}Conv2dconv_inr AdapterBlockrrbodyrr rerfrgrr5r$s&&&&& rrFullAdapter.__init__5s !a$77 **+;<yyqkqRST MMXa[(1+~F #1c(m44!a%(+~TXY4   '7s8}q?P9Q&Q#s!+D c^<V^8dQhRS[PRS[S[P,/#rsrt)rrs"rrrOs($u||*<rc VPV4pVPV4p.pVPFpV!V4pVPV4K V#)a This method processes the input tensor `x` through the FullAdapter model and performs operations including pixel unshuffling, convolution, and a stack of AdapterBlocks. It returns a list of feature tensors, each capturing information at a different stage of processing within the FullAdapter model. The number of feature tensors in the list is determined by the number of downsample blocks specified during initialization. r}rrrOr r1r4blocks&& rr6FullAdapter.forwardOsN NN1  LLOYYEaA OOA rrrrr}r rXrYrZr[r\rr6r^r_r`ras@@rrnrn0s3 4 ! RR4rrncdaa]tRtRtoRt^.RO^^3V3RlV3RllltV3RlRltRtVtV;t #) roibrcB<V^8dQhRS[RS[S[,RS[RS[/#rr)rrs"rrFullAdapterXL.__annotate__gs7;;;s); ;  ;rc <\SV`4W^,,p\P!V4Vn\P !W^,^^R7Vn.Vn\\V44FpV^8Xd<VPP\W%^, ,W%,V44KEV^8Xd>VPP\W%^, ,W%,VRR74KVPP\W%,W%,V44K \P!VP4VnV^,Vn R#r)rrrrr}rrrrrrOrrrrs&&&&& rrFullAdapterXL.__init__gs !a$77 **+;<yyqkqRST  s8}%AAv   h1uox{N![\a   h1uox{Nae!fg   hk8;!WX &MM$)), &6&:#rc^<V^8dQhRS[PRS[S[P,/#rsrt)rrs"rrrs($u||*<rc VPV4pVPV4p.pVPFpV!V4pVPV4K V#)z This method takes the tensor x as input and processes it through FullAdapterXL model. It consists of operations including unshuffling pixels, applying convolution layer and appending each block into list of feature tensors. rrs&& rr6FullAdapterXL.forwardsN NN1  LLOYYEaA OOA rrrrras@@rrorobs1 4 " ;;8rrocXaa]tRtRtoRtRV3RlV3RllltV3RlRltRtVtV;t #) ria An AdapterBlock is a helper model that contains multiple ResNet-like blocks. It is used in the `FullAdapter` and `FullAdapterXL` models. Args: in_channels (`int`): Number of channels of AdapterBlock's input. out_channels (`int`): Number of channels of AdapterBlock's output. num_res_blocks (`int`): Number of ResNet blocks in the AdapterBlock. down (`bool`, *optional*, defaults to `False`): If `True`, perform downsampling on AdapterBlock's input. c2<V^8dQhRS[RS[RS[RS[/#r re out_channelsrgrrirA)rrs"rrAdapterBlock.__annotate__s*   C  s  C  W[  rcR<\SV`4RVnV'd\P!^^RR7VnRVnW8wd\P !W^R7Vn\P!\V4Uu.uFp\V4NK up!Vn R#uupi)NTrstride ceil_moder) rr downsampler AvgPool2din_convr SequentialrAdapterResnetBlockresnets)r rerrgrrCr$s&&&&& rrAdapterBlock.__init__s}   llqdSDO  &99[ANDL}}8=n8M N8M1 .8M N  NsB$cN<V^8dQhRS[PRS[P/#rsr*r+)rrs"rrrs#%,,rc VPeVPV4pVPeVPV4pVPV4pV#)z This method takes tensor x as input and performs operations downsampling and convolutional layers if the self.downsample and self.in_conv properties of AdapterBlock model are specified. Then it applies a series of residual blocks to the input tensor. rrrrws&&rr6AdapterBlock.forwardsE ?? &"A << # QA LLOrrFrras@@rrrs#    rrcTaa]tRtRtoRtV3RlV3RlltV3RlRltRtVtV;t #)riz An `AdapterResnetBlock` is a helper model that implements a ResNet-like block. Args: channels (`int`): Number of channels of AdapterResnetBlock's input and output. c <V^8dQhRS[/#r rfri)rrs"rrAdapterResnetBlock.__annotate__sCCCrc<\SV`4\P!W^^R7Vn\P !4Vn\P!W^R7VnR#)rrNrrrrblock1ReLUactblock2r rfr$s&&rrAdapterResnetBlock.__init__sA ii1M 779iiB rcN<V^8dQhRS[PRS[P/#rsr)rrs"rrr#   %,, rc tVPVPV44pVPV4pW!,#)z This method takes input tensor x and applies a convolutional layer, ReLU activation, and another convolutional layer on the input tensor. It returns addition with the input tensor. rrrr r1hs&& rr6AdapterResnetBlock.forward. HHT[[^ $ KKNu rrrras@@rrrs%CC   rrcdaa]tRtRtoRt^.RO^^3V3RlV3RllltV3RlRltRtVtV;t #) rpircB<V^8dQhRS[RS[S[,RS[RS[/#rr)rrs"rrLightAdapter.__annotate__s=NNNs)N N  Nrc <\SV`4W^,,p\P!V4Vn\P !\ W^,V4.\\V4^, 4Uu.uF%p\ W%,W%^,,VRR7NK' upO\ VR,VR,VRR7N4Vn V^\V4,,Vn R#uupi)r TrN) rrrrr}rLightAdapterBlockrrrrrs&&&&& rrLightAdapter.__init__s !a$77 **+;<MM!+{NK #3x=1#455&hk8E?NY]^5  "(2, nSWX     '7!s8}:L&M#s:+C/ c^<V^8dQhRS[PRS[S[P,/#rsrt)rrs"rrrs(   $u||*< rc VPV4p.pVPFpV!V4pVPV4K V#)z This method takes the input tensor x and performs downscaling and appends it in list of feature tensors. Each feature tensor corresponds to a different level of processing within the LightAdapter. )r}rrOrs&& rr6LightAdapter.forwardsA NN1 YYEaA OOA r)rrr})rrrrras@@rrprps3 . ! NN4   rrpcXaa]tRtRtoRtRV3RlV3RllltV3RlRltRtVtV;t #) ria  A `LightAdapterBlock` is a helper model that contains multiple `LightAdapterResnetBlocks`. It is used in the `LightAdapter` model. Args: in_channels (`int`): Number of channels of LightAdapterBlock's input. out_channels (`int`): Number of channels of LightAdapterBlock's output. num_res_blocks (`int`): Number of LightAdapterResnetBlocks in the LightAdapterBlock. down (`bool`, *optional*, defaults to `False`): If `True`, perform downsampling on LightAdapterBlock's input. c2<V^8dQhRS[RS[RS[RS[/#rr)rrs"rrLightAdapterBlock.__annotate__!s0 M MC Ms MC MW[ Mrc<\SV`4V^,pRVnV'd\P!^^RR7Vn\P !W^R7Vn\P!\V4Uu.uFp\V4NK up!Vn \P !WR^R7Vn R#uupi)NTrr) rrrrrrrrrLightAdapterResnetBlockrout_conv)r rerrgr mid_channelsrCr$s&&&&& rrLightAdapterBlock.__init__!s #q(   llqdSDOyyJ }}V[\jVk&lVkQR'>|'LVk&lm  ,!L 'msB=cN<V^8dQhRS[PRS[P/#rsr)rrs"rrr-s#   %,, rc VPeVPV4pVPV4pVPV4pVPV4pV#)z This method takes tensor x as input and performs downsampling if required. Then it applies in convolution layer, a sequence of residual blocks, and out convolutional layer. )rrrrrws&&rr6LightAdapterBlock.forward-sI ?? &"A LLO LLO MM! r)rrrrrrras@@rrrs%  M M   rrcTaa]tRtRtoRtV3RlV3RlltV3RlRltRtVtV;t #)ri<z A `LightAdapterResnetBlock` is a helper model that implements a ResNet-like block with a slightly different architecture than `AdapterResnetBlock`. Args: channels (`int`): Number of channels of LightAdapterResnetBlock's input and output. c <V^8dQhRS[/#rr)rrs"rr$LightAdapterResnetBlock.__annotate__FsNNNrc<\SV`4\P!W^^R7Vn\P !4Vn\P!W^^R7VnR#)rrNrrs&&rr LightAdapterResnetBlock.__init__FsC ii1M 779ii1M rcN<V^8dQhRS[PRS[P/#rsr)rrs"rrrLrrc tVPVPV44pVPV4pW!,#)z This function takes input tensor x and processes it through one convolutional layer, ReLU activation, and another convolutional layer and adds it to input tensor. rrs&& rr6LightAdapterResnetBlock.forwardLrrrrras@@rrr<s%NN   rr)r?typingrr*torch.nnrconfiguration_utilsrrutilsrmodeling_utilsr get_loggerrXrPr r Modulernrorrrprrrrrs  A&   H %~:~BM7[M7f/"))/d/BII/d-299-`<,299,^( (Vbiir