+h"SSKrSSKJrJrJrJrJr SSKrSSKJ r SSK J r J r J r JrJrJrJrJrJrJrJr SSKJrJrJrJrJrJr SSKJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r* S r+\"S S 5(a6\"5(a*\"S S 5(a\"5(a\"S S5(aSr+\RX"\-5r.Sr/Sr0Sr1SS0r2Sr3"SS\5r4"SS\5r5"SS\5r6"SS\5r7"SS\5r8"S S!\45r9"S"S#\5r:"S$S%\5r;"S&S'\5r<"S(S)\5r="S*S+\5r>"S,S-\5r?"S.S/\5r@"S0S1\5rA"S2S3\5rB"S4S5\5rC"S6S7\5rD"S8S9\45rEg):N)CallableDictListOptionalUnion)validate_hf_hub_args) USE_PEFT_BACKEND deprecateget_submodule_by_nameis_bitsandbytes_availableis_gguf_availableis_peft_availableis_peft_versionis_torch_versionis_transformers_availableis_transformers_versionlogging)LORA_WEIGHT_NAMELORA_WEIGHT_NAME_SAFE LoraBaseMixin_fetch_state_dict_load_lora_into_text_encoder_pack_dict_with_prefix) +_convert_bfl_flux_control_lora_to_diffusers&_convert_fal_kontext_lora_to_diffusers(_convert_hunyuan_video_lora_to_diffusers%_convert_kohya_flux_lora_to_diffusers%_convert_musubi_wan_lora_to_diffusers0_convert_non_diffusers_hidream_lora_to_diffusers(_convert_non_diffusers_lora_to_diffusers-_convert_non_diffusers_ltxv_lora_to_diffusers0_convert_non_diffusers_lumina2_lora_to_diffusers-_convert_non_diffusers_qwen_lora_to_diffusers,_convert_non_diffusers_wan_lora_to_diffusers%_convert_xlabs_flux_lora_to_diffusers"_maybe_map_sgm_blocks_to_diffusersF>=z1.9.00.13.1>z4.45.2T text_encoderunet transformer x_embedder in_channelsc[5(aSSKJn [5(aSSKJn UR RRS:HnUR RRS:HnUR RRS:HnU(a[5(d [S5eU(a[5(d [S5eU(a[5(d [S 5eS nUR RRS :XaS n[[S 5(a([RR5ROSnU(dU(apW"U(aUR R!U5O UR U(aUR R"O UR$UR&S9R(n OmU(aPW"U(aUR R!U5O UR 5n U R!UR&5n OUR R(n U(aU R+5n U $)Nr )dequantize_bnb_weight)dequantize_gguf_tensor Params4bit Int8Params GGUFParameterz~The checkpoint seems to have been quantized with `bitsandbytes` (4bits). Install `bitsandbytes` to load quantized checkpoints.z~The checkpoint seems to have been quantized with `bitsandbytes` (8bits). Install `bitsandbytes` to load quantized checkpoints.zfThe checkpoint seems to have been quantized with `gguf`. Install `gguf` to load quantized checkpoints.FcpuT acceleratorcuda)statedtype)r quantizers.bitsandbytesr2rquantizers.gguf.utilsr3weight __class____name__ ValueErrordevicetypehasattrtorchr8current_acceleratorto quant_stater:r;datar7) modelmoduler2r3is_bnb_4bit_quantizedis_bnb_8bit_quantizedis_gguf_quantized weight_on_cpurB module_weights Y/home/james-whalen/.local/lib/python3.13/site-packages/diffusers/loaders/lora_pipeline.py*_maybe_dequantize_weight_for_expanded_lorarROs ""CB"MM33<< L"MM33<< L //88OK%>%@%@ M  %>%@%@ M  !2!4!4 t  M }}  E) =DUM=Z=ZU   2 2 4 9 9`fF 5-(5FMM  V $6==/D&--++&,,++  $  .(5FMM  V $6== &((5  ** %))+ c`^\rSrSrSrSS/r\r\r SS\ \ \ \ \ R44S\\ S \4S jjr\\S\ \ \ \ \ R444S j55r\SS \4S jj5r\S S \4Sjj5r\S!S\ \ \R04S\ \ \ \ R2R4\ R44S\ \ \ R2R44S\S\ S\S\4Sjj5rSS/S SS4S\\ S\S\S\\\ 4U4SjjjrSS/4S\\ 4U4Sjjjr Sr!U=r"$)"StableDiffusionLoraLoaderMixinz Load LoRA layers into Stable Diffusion [`UNet2DConditionModel`] and [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel). r-r,NF%pretrained_model_name_or_path_or_dict adapter_namehotswapc [(d [S5eURS[5nU(a[ SS5(d [S5e[ U[ 5(aUR5nSUS'UR"U40UD6upgn[SUR555n U (d [S 5eURUU[US 5(d[XR5O URUUUUUS 9 UR!UU[US 5(d[XR"5O UR$UR&UUUUUS 9 g)aw Load LoRA weights specified in `pretrained_model_name_or_path_or_dict` into `self.unet` and `self.text_encoder`. All kwargs are forwarded to `self.lora_state_dict`. See [`~loaders.StableDiffusionLoraLoaderMixin.lora_state_dict`] for more details on how the state dict is loaded. See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet`] for more details on how the state dict is loaded into `self.unet`. See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_into_text_encoder`] for more details on how the state dict is loaded into `self.text_encoder`. Parameters: pretrained_model_name_or_path_or_dict (`str` or `os.PathLike` or `dict`): See [`~loaders.StableDiffusionLoraLoaderMixin.lora_state_dict`]. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): Defaults to `False`. Whether to substitute an existing (LoRA) adapter with the newly loaded adapter in-place. This means that, instead of loading an additional adapter, this will take the existing adapter weights and replace them with the weights of the new adapter. This can be faster and more memory efficient. However, the main advantage of hotswapping is that when the model is compiled with torch.compile, loading the new adapter does not require recompilation of the model. When using hotswapping, the passed `adapter_name` should be the name of an already loaded adapter. If the new adapter and the old adapter have different ranks and/or LoRA alphas (i.e. scaling), you need to call an additional method before loading the adapter: ```py pipeline = ... # load diffusers pipeline max_rank = ... # the highest rank among all LoRAs that you want to load # call *before* compiling and loading the LoRA adapter pipeline.enable_lora_hotswap(target_rank=max_rank) pipeline.load_lora_weights(file_name) # optionally compile the model now ``` Note that hotswapping adapters of the text encoder is not yet supported. There are some further limitations to this technique, which are documented here: https://huggingface.co/docs/peft/main/en/package_reference/hotswap kwargs (`dict`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.lora_state_dict`]. )PEFT backend is required for this method.low_cpu_mem_usager)r*q`low_cpu_mem_usage=True` is not compatible with this `peft` version. Please update it with `pip install -U peft`.Treturn_lora_metadatac3,# UH nSU;v M g7floraN.0keys rQ CStableDiffusionLoraLoaderMixin.load_lora_weights..K9J## 9JInvalid LoRA checkpoint.r-network_alphasr-rXmetadata _pipeliner\rYr,)rlr, lora_scalerXrnrmr\rYN)r rApop_LOW_CPU_MEM_USAGE_DEFAULT_LORAr isinstancedictcopylora_state_dictallkeysload_lora_into_unetrDgetattr unet_namer-load_lora_into_text_encodertext_encoder_namer,ro selfrWrXrYkwargsr\ state_dictrlrmis_correct_formats rQload_lora_weights0StableDiffusionLoraLoaderMixin.load_lora_weightss[p HI I"JJ':<[\ _T8%D%DD  ;T B B4Y4^4^4` 1*.%&/3/C/CDi/tms/t, HK9JKK 78 8   )6=dF6K6K~~.QUQZQZ%/ !  (( )400!'='=>""%/ ) rSc PURSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n URS S5n SnU cSn SnSSS.n[UU U UUUUUUU UUS9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnnSn[ SUR555(aU b [UU 5n[U5unnU (aUUU4nU$UU4nU$s snnf) Return state dict for lora weights and the network alphas. We support loading A1111 formatted LoRA checkpoints in a limited capacity. This function is experimental and might change in the future. Parameters: pretrained_model_name_or_path_or_dict (`str` or `os.PathLike` or `dict`): Can be either: - A string, the *model id* (for example `google/ddpm-celebahq-256`) of a pretrained model hosted on the Hub. - A path to a *directory* (for example `./my_model_directory`) containing the model weights saved with [`ModelMixin.save_pretrained`]. - A [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict). cache_dir (`Union[str, os.PathLike]`, *optional*): Path to a directory where a downloaded pretrained model configuration is cached if the standard cache is not used. force_download (`bool`, *optional*, defaults to `False`): Whether or not to force the (re-)download of the model weights and configuration files, overriding the cached versions if they exist. proxies (`Dict[str, str]`, *optional*): A dictionary of proxy servers to use by protocol or endpoint, for example, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. The proxies are used on each request. local_files_only (`bool`, *optional*, defaults to `False`): Whether to only load local model weights and configuration files or not. If set to `True`, the model won't be downloaded from the Hub. token (`str` or *bool*, *optional*): The token to use as HTTP bearer authorization for remote files. If `True`, the token generated from `diffusers-cli login` (stored in `~/.huggingface`) is used. revision (`str`, *optional*, defaults to `"main"`): The specific model version to use. It can be a branch name, a tag name, a commit id, or any identifier allowed by Git. subfolder (`str`, *optional*, defaults to `""`): The subfolder location of a model file within a larger model repository on the Hub or locally. weight_name (`str`, *optional*, defaults to None): Name of the serialized state dict file. return_lora_metadata (`bool`, *optional*, defaults to False): When enabled, additionally return the LoRA adapter metadata, typically found in the state dict. cache_dirNforce_downloadFproxieslocal_files_onlytokenrevision subfolder weight_name unet_configuse_safetensorsr^Tattn_procs_weightspytorch file_type framework rWrrrrrrrrr user_agent allow_picklec3,# UH nSU;v M g7f dora_scaleNrbrdks rQrfAStableDiffusionLoraLoaderMixin.lora_state_dict..I#Jz!LA$5zri!It seems like you are using a DoRA checkpoint that is not compatible in Diffusers at the moment. So, we are going to filter out the keys associated to 'dora_scale` from the state dict. If you think this is a mistake please open an issue https://github.com/huggingface/diffusers/issues/new.rc3# UH^nURS5=(dA URS5=(d) URS5=(d URS5v M` g7flora_te_ lora_unet_ lora_te1_ lora_te2_N startswithrs rQrfrQ^ '  Z(-<< --<< ,-<< ,- 'A&A( rpranyloggerwarningitemsrvrwr(r"clsrWrrrrrrrrrrrr^rrrrmis_dora_scale_presentwarn_msgrvrlouts rQru.StableDiffusionLoraLoaderMixin.lora_state_dictsrJJ{D1 $4e<**Y-!::&8$? 7D)::j$/JJ{D1 jj5 jj5  **%6=%zz*@%H  ""OL#7iP 02W#+-)!%  H!$#Jz#J J {H NN8 $+5+;+;+=W+=41aUVAV$!Q$+=JW   __&   &? KX )QR\)] &J8Lz>84 T^_mRn )X / F"F"c [(d [S5eU(a[SS5(d [S5e[R SUR S35 UR UUR UUUUUUS9 g a This will load the LoRA layers specified in `state_dict` into `unet`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. network_alphas (`Dict[str, float]`): The value of the network alpha used for stable learning and preventing underflow. This value has the same meaning as the `--network_alpha` option in the kohya-ss trainer script. Refer to [this link](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning). unet (`UNet2DConditionModel`): The UNet model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r[r)r*r]Loading .)prefixrlrXrmrnr\rYNr rArrinforzload_lora_adapter rrrlr-rXrnr\rYrms rQrx2StableDiffusionLoraLoaderMixin.load_lora_into_unetcsL HI I _T8%D%DD   hs}}oQ/0  ==)%/  rS?c >[UUUUUURUU UUU S9 ga} This will load the LoRA layers specified in `state_dict` into `text_encoder` Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The key should be prefixed with an additional `text_encoder` to distinguish between unet lora layers. network_alphas (`Dict[str, float]`): The value of the network alpha used for stable learning and preventing underflow. This value has the same meaning as the `--network_alpha` option in the kohya-ss trainer script. Refer to [this link](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning). text_encoder (`CLIPTextModel`): The text encoder model to load the LoRA layers into. prefix (`str`): Expected prefix of the `text_encoder` in the `state_dict`. lora_scale (`float`): How much to scale the output of the lora linear layer before it is added with the output of the regular lora layer. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. ) rrlror,rr|rXrmrnr\rYNrr| rrrlr,rrorXrnr\rYrms rQr{:StableDiffusionLoraLoaderMixin.load_lora_into_text_encoders4X %!)!%!33%/ rSsave_directoryunet_lora_layerstext_encoder_lora_layersis_main_processr save_functionsafe_serializationc 0n 0n U(dU(d [S5eU(a*U RURX R55 U(a*U RURX0R55 U(a$U R[ XR55 U (a$U R[ XR55 UR U UUUUUU S9 g)ux Save the LoRA parameters corresponding to the UNet and text encoder. Arguments: save_directory (`str` or `os.PathLike`): Directory to save LoRA parameters to. Will be created if it doesn't exist. unet_lora_layers (`Dict[str, torch.nn.Module]` or `Dict[str, torch.Tensor]`): State dict of the LoRA layers corresponding to the `unet`. text_encoder_lora_layers (`Dict[str, torch.nn.Module]` or `Dict[str, torch.Tensor]`): State dict of the LoRA layers corresponding to the `text_encoder`. Must explicitly pass the text encoder LoRA state dict because it comes from 🤗 Transformers. is_main_process (`bool`, *optional*, defaults to `True`): Whether the process calling this is the main process or not. Useful during distributed training and you need to call this function on all processes. In this case, set `is_main_process=True` only on the main process to avoid race conditions. save_function (`Callable`): The function to use to save the state dictionary. Useful during distributed training when you need to replace `torch.save` with another method. Can be configured with the environment variable `DIFFUSERS_SAVE_MODE`. safe_serialization (`bool`, *optional*, defaults to `True`): Whether to save the model using `safetensors` or the traditional PyTorch way with `pickle`. unet_lora_adapter_metadata: LoRA adapter metadata associated with the unet to be serialized with the state dict. text_encoder_lora_adapter_metadata: LoRA adapter metadata associated with the text encoder to be serialized with the state dict. zPYou must pass at least one of `unet_lora_layers` and `text_encoder_lora_layers`.rrrrrrlora_adapter_metadataN)rAupdate pack_weightsrzr|rwrite_lora_layers) rrrrrrrrunet_lora_adapter_metadata"text_encoder_lora_adapter_metadatarrs rQsave_lora_weights0StableDiffusionLoraLoaderMixin.save_lora_weightssN " $<op p    c../?O P #   c../GI^I^_ ` % ! ( ()?@Z\i\i)j k - ! ( (&'IK`K`a  !)+#'1"7  rS componentsro safe_fusing adapter_namesc 0>[TU]"SUUUUS.UD6 g Fuses the LoRA parameters into the original parameters of the corresponding blocks. This is an experimental API. Args: components: (`List[str]`): List of LoRA-injectable components to fuse the LoRAs into. lora_scale (`float`, defaults to 1.0): Controls how much to influence the outputs with the LoRA parameters. safe_fusing (`bool`, defaults to `False`): Whether to check fused weights for NaN values before fusing and if values are NaN not fusing them. adapter_names (`List[str]`, *optional*): Adapter names to be used for fusing. If nothing is passed, all active adapters will be fused. Example: ```py from diffusers import DiffusionPipeline import torch pipeline = DiffusionPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16 ).to("cuda") pipeline.load_lora_weights("nerijs/pixel-art-xl", weight_name="pixel-art-xl.safetensors", adapter_name="pixel") pipeline.fuse_lora(lora_scale=0.7) ``` rrorrNrbsuper fuse_lorar~rrorrrr?s rQr(StableDiffusionLoraLoaderMixin.fuse_lora .N  !!#'    rSc *>[TU]"SSU0UD6 gab Reverses the effect of [`pipe.fuse_lora()`](https://huggingface.co/docs/diffusers/main/en/api/loaders#diffusers.loaders.LoraBaseMixin.fuse_lora). This is an experimental API. Args: components (`List[str]`): List of LoRA-injectable components to unfuse LoRA from. unfuse_unet (`bool`, defaults to `True`): Whether to unfuse the UNet LoRA parameters. unfuse_text_encoder (`bool`, defaults to `True`): Whether to unfuse the text encoder LoRA parameters. If the text encoder wasn't monkey-patched with the LoRA parameters then it won't have any effect. rNrbr unfuse_lorar~rrr?s rQr*StableDiffusionLoraLoaderMixin.unfuse_loraO$  %n5I) '+ c /4S$sELL?P:Q5Q/Rc smc  c Jp/4S$sELL?P:Q5Q/Rppd : : : x 7 7 7 rMQ?C $"&#'#'+/C c2;;./C sE%((//5<<*G$HHIC #'sEHHOO';"< C  C  C  C !C C N"( 8!-1 - I- -  -  S * - - ^4:>2J=d3i==rSrUc^\rSrSrSr/SQr\r\r SS\ \ \ \ \ R44S\\ S\4S jjr\\S\ \ \ \ \ R444S j55r\SS\4S jj5r\S S\4S jj5r\S!S\ \ \R04S\ \ \ \ R2R4\ R44S\ \ \ \ R2R4\ R44S\ \ \ \ R2R4\ R44S\S\ S\S\4Sjj5r/SQS SS4S\\ S\S\S\\\ 4U4Sjjjr/SQ4S\\ 4U4Sjjjr Sr!U=r"$)" StableDiffusionXLLoraLoaderMixinida3 Load LoRA layers into Stable Diffusion XL [`UNet2DConditionModel`], [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), and [`CLIPTextModelWithProjection`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection). )r-r,text_encoder_2NFrWrXrYc [(d [S5eURS[5nU(a[ SS5(d [S5e[ U[ 5(aUR5nSUS'UR"U4SURR0UD6upgn[S UR555n U (d [S 5eURUUURUUUUUS 9 URUUURUR UR"UUUUUS 9 URUUUR$UR S 3UR"UUUUUS 9 g)a7 Load LoRA weights specified in `pretrained_model_name_or_path_or_dict` into `self.unet` and `self.text_encoder`. All kwargs are forwarded to `self.lora_state_dict`. See [`~loaders.StableDiffusionLoraLoaderMixin.lora_state_dict`] for more details on how the state dict is loaded. See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet`] for more details on how the state dict is loaded into `self.unet`. See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_into_text_encoder`] for more details on how the state dict is loaded into `self.text_encoder`. Parameters: pretrained_model_name_or_path_or_dict (`str` or `os.PathLike` or `dict`): See [`~loaders.StableDiffusionLoraLoaderMixin.lora_state_dict`]. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. kwargs (`dict`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.lora_state_dict`]. r[r\r)r*r]Tr^rc3,# UH nSU;v M g7fr`rbrcs rQrfEStableDiffusionXLLoraLoaderMixin.load_lora_weights..rhrirjrk rlr,rrorXrmrnr\rY_2N)r rArprqrrrrsrtrur-configrvrwrxr{r,r|rorr}s rQr2StableDiffusionXLLoraLoaderMixin.load_lora_weightsosH HI I"JJ':<[\ _T8%D%DD  ;T B B4Y4^4^4` 1*.%&/3/C/C 10  ((0 0 , H  K9JKK 78 8   )%/ !  (( )**))%/ )  (( ),,,,-R0%/ ) rSc PURSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n URS S5n SnU cSn SnSSS.n[UU U UUUUUUU UUS9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnnSn[ SUR555(aU b [UU 5n[U5unnU (aUUU4nU$UU4nU$s snnf)rrNrFrrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrfCStableDiffusionXLLoraLoaderMixin.lora_state_dict...rrirrc3# UH^nURS5=(dA URS5=(d) URS5=(d URS5v M` g7frrrs rQrfr6rrrrs rQru0StableDiffusionXLLoraLoaderMixin.lora_state_dictstJJ{D1 $4e<**Y-!::&8$? 7D)::j$/JJ{D1 jj5 jj5  **%6=%zz*@%H  ""OL#7iP 02W#+-)!%  H!$#Jz#J J {H NN8 $+5+;+;+=W+=41aUVAV$!Q$+=JW   __&   &? KX )QR\)] &J8Lz>84 T^_mRn )Xrc [(d [S5eU(a[SS5(d [S5e[R SUR S35 UR UUR UUUUUUS9 grrrs rQrx4StableDiffusionXLLoraLoaderMixin.load_lora_into_unetHsN HI I _T8%D%DD   hs}}oQ/0  ==)%/  rSrc >[UUUUUURUU UUU S9 grrrs rQr{[TU]"SUUUUS.UD6 grrrs rQr*StableDiffusionXLLoraLoaderMixin.fuse_lorarrSc *>[TU]"SSU0UD6 grrrs rQr,StableDiffusionXLLoraLoaderMixin.unfuse_loraFrrSrbrrr NNNTNNTNNNrrs@rQrrdsq HI) '+ b /4S$sELL?P:Q5Q/Rb smb  b Hp/4S$sELL?P:Q5Q/Rppd: : : x7 7 7 rMQTXVZ $"&#'#'+/-1S c2;;./S sE%((//5<<*G$HHIS #'sE%((//5<<2O,P'P"Q S %)eEHHOOU\\4Q.R)R$S S  S S  S !S S n!K!-1 - I- -  -  S * - - ^3]=d3i==rSrc^\rSrSrSr/SQr\r\r \ \ S\ \ \\ \R 444Sj55rSS\ \ \\ \R 44S\4S jjr\ SS\4S jj5r\ SS\4S jj5r\ S S \ \ \R.4S\\ \ \R0R2\R 44S\\ \ \R0R2\R 44S\\ \ \R0R2\R 44S\S\ S\S\4Sjj5r/SQS SS4S\\ S\S\S\\\ 4U4Sjjjr/SQ4S\\ 4U4Sjjjr Sr!U=r"$)!SD3LoraLoaderMixini[aK Load LoRA layers into [`SD3Transformer2DModel`], [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), and [`CLIPTextModelWithProjection`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection). Specific to [`StableDiffusion3Pipeline`]. )r.r,rrWc URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnnU (aUU4nU$UnU$s snnf)< Return state dict for lora weights and the network alphas. We support loading A1111 formatted LoRA checkpoints in a limited capacity. This function is experimental and might change in the future. Parameters: pretrained_model_name_or_path_or_dict (`str` or `os.PathLike` or `dict`): Can be either: - A string, the *model id* (for example `google/ddpm-celebahq-256`) of a pretrained model hosted on the Hub. - A path to a *directory* (for example `./my_model_directory`) containing the model weights saved with [`ModelMixin.save_pretrained`]. - A [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict). cache_dir (`Union[str, os.PathLike]`, *optional*): Path to a directory where a downloaded pretrained model configuration is cached if the standard cache is not used. force_download (`bool`, *optional*, defaults to `False`): Whether or not to force the (re-)download of the model weights and configuration files, overriding the cached versions if they exist. proxies (`Dict[str, str]`, *optional*): A dictionary of proxy servers to use by protocol or endpoint, for example, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. The proxies are used on each request. local_files_only (`bool`, *optional*, defaults to `False`): Whether to only load local model weights and configuration files or not. If set to `True`, the model won't be downloaded from the Hub. token (`str` or *bool*, *optional*): The token to use as HTTP bearer authorization for remote files. If `True`, the token generated from `diffusers-cli login` (stored in `~/.huggingface`) is used. revision (`str`, *optional*, defaults to `"main"`): The specific model version to use. It can be a branch name, a tag name, a commit id, or any identifier allowed by Git. subfolder (`str`, *optional*, defaults to `""`): The subfolder location of a model file within a larger model repository on the Hub or locally. return_lora_metadata (`bool`, *optional*, defaults to False): When enabled, additionally return the LoRA adapter metadata, typically found in the state dict. rNrFrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrf5SD3LoraLoaderMixin.lora_state_dict..rrirrrprrrrrrrWrrrrrrrrrrr^rrrrmrrrrrs rQru"SD3LoraLoaderMixin.lora_state_dicths}pJJ{D1 $4e<**Y-!::&8$? 7D)::j$/JJ{D1 jj5  **%6=%zz*@%H  ""OL#7iP 02W#+-)!%  H!$#Jz#J J {H NN8 $+5+;+;+=W+=41aUVAV$!Q$+=JW(.rhrirjr.r.rXrmrnr\rYNr r )r rArprqrrrrsrtrurvrwload_lora_into_transformerrDrytransformer_namer.r{r,r|ror r~rWrXrYrr\rrmrs rQr$SD3LoraLoaderMixin.load_lora_weightssB HI I"JJ':<[\ h!?!?D  ;T B B4Y4^4^4` 1*.%&#334Yd]cd K9JKK 78 8 '' DKDR_D`D`&;&;[UUUUUURUU UUU S9 grrrs rQr{.SD3LoraLoaderMixin.load_lora_into_text_encoderTrrSrtransformer_lora_layersrrrrrrc `0n 0n U(dU(dU(d [S5eU(a*U RURX R55 U(a!U RURUS55 U(a!U RURUS55 U b$U R[ XR55 U (a$U R[ XR 55 U (aU R[ U S55 UR U UUUUUU S9 g)u: Save the LoRA parameters corresponding to the UNet and text encoder. Arguments: save_directory (`str` or `os.PathLike`): Directory to save LoRA parameters to. Will be created if it doesn't exist. transformer_lora_layers (`Dict[str, torch.nn.Module]` or `Dict[str, torch.Tensor]`): State dict of the LoRA layers corresponding to the `transformer`. text_encoder_lora_layers (`Dict[str, torch.nn.Module]` or `Dict[str, torch.Tensor]`): State dict of the LoRA layers corresponding to the `text_encoder`. Must explicitly pass the text encoder LoRA state dict because it comes from 🤗 Transformers. text_encoder_2_lora_layers (`Dict[str, torch.nn.Module]` or `Dict[str, torch.Tensor]`): State dict of the LoRA layers corresponding to the `text_encoder_2`. Must explicitly pass the text encoder LoRA state dict because it comes from 🤗 Transformers. is_main_process (`bool`, *optional*, defaults to `True`): Whether the process calling this is the main process or not. Useful during distributed training and you need to call this function on all processes. In this case, set `is_main_process=True` only on the main process to avoid race conditions. save_function (`Callable`): The function to use to save the state dictionary. Useful during distributed training when you need to replace `torch.save` with another method. Can be configured with the environment variable `DIFFUSERS_SAVE_MODE`. safe_serialization (`bool`, *optional*, defaults to `True`): Whether to save the model using `safetensors` or the traditional PyTorch way with `pickle`. transformer_lora_adapter_metadata: LoRA adapter metadata associated with the transformer to be serialized with the state dict. text_encoder_lora_adapter_metadata: LoRA adapter metadata associated with the text encoder to be serialized with the state dict. text_encoder_2_lora_adapter_metadata: LoRA adapter metadata associated with the second text encoder to be serialized with the state dict. zrYou must pass at least one of `transformer_lora_layers`, `text_encoder_lora_layers`, `text_encoder_2_lora_layers`.r,rNr)rArrr1rr|r)rrr;rrrrrr!transformer_lora_adapter_metadatarrrrs rQr$SD3LoraLoaderMixin.save_lora_weightss^ "'+CGaE  #   c../FH\H\] ^ #   c../GX Y %   c../IK[\ ] , 8 ! ( (&'HJ^J^_  . ! ( (&'IK`K`a  0 ! ( (&'KM]^  !)+#'1"7  rSrrorrc 0>[TU]"SUUUUS.UD6 grrrs rQrSD3LoraLoaderMixin.fuse_lorarrSc *>[TU]"SSU0UD6 g)ai Reverses the effect of [`pipe.fuse_lora()`](https://huggingface.co/docs/diffusers/main/en/api/loaders#diffusers.loaders.LoraBaseMixin.fuse_lora). This is an experimental API. Args: components (`List[str]`): List of LoRA-injectable components to unfuse LoRA from. unfuse_transformer (`bool`, defaults to `True`): Whether to unfuse the UNet LoRA parameters. unfuse_text_encoder (`bool`, defaults to `True`): Whether to unfuse the text encoder LoRA parameters. If the text encoder wasn't monkey-patched with the LoRA parameters then it won't have any effect. rNrbrrs rQrSD3LoraLoaderMixin.unfuse_lorarrSrbrrrr)#r@rrrrrTRANSFORMER_NAMEr1rr|rrrrrrErrurrr0r{rrrrrrrrrrrrrrs@rQr!r![saO')^/4S$sELL?P:Q5Q/R^^F V /4S$sELL?P:Q5Q/RV  V p / / / b7 7 7 r TXTXVZ $"&#'*.+/-1U c2;;./U "&c5%,,1N+O&O!PU #'sE%((//5<<2O,P'P"Q U %)eEHHOOU\\4Q.R)R$S U  U U  U !U U t!R!-1 - I- -  -  S * - - `3d=d3i==rSr!c^\rSrSrSrS/r\r\\ S\ \ \ \ \ R444Sj55rSS\ \ \ \ \ R44S\\ S \4S jjr\SS \4S jj5r\SS \ \ \R*4S \ \ \ \ R,R.\ R44S\S\ S\S\S\\4Sjj5rS/SSS4S\\ S\S\S\\\ 4U4SjjjrSS/4S\\ 4U4SjjjrSrU=r $) AuraFlowLoraLoaderMixini.zX Load LoRA layers into [`AuraFlowTransformer2DModel`] Specific to [`AuraFlowPipeline`]. r.rWc URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnnU (aUU4nU$UnU$s snnf)r#rNrFrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrf:AuraFlowLoraLoaderMixin.lora_state_dict..rrirrr&r's rQru'AuraFlowLoraLoaderMixin.lora_state_dict6}rJJ{D1 $4e<**Y-!::&8$? 7D)::j$/JJ{D1 jj5  **%6=%zz*@%H  ""OL#7iP 02W#+-)!%  H!$#Jz#J J {H NN8 $+5+;+;+=W+=41aUVAV$!Q$+=JW(.rhrirjr.r/Nr rArprqrrrrsrtrurvrwr0rDryr1r.r2s rQr)AuraFlowLoraLoaderMixin.load_lora_weights8 HI I"JJ':<[\ h!?!?D  ;T B B4Y4^4^4` 1*.%&#334Yd]cd K9JKK 78 8 '' DKDR_D`D`&;&;[TU]"SUUUUS.UD6 grrrs rQr!AuraFlowLoraLoaderMixin.fuse_loraBrrSr,c *>[TU]"SSU0UD6 ga Reverses the effect of [`pipe.fuse_lora()`](https://huggingface.co/docs/diffusers/main/en/api/loaders#diffusers.loaders.LoraBaseMixin.fuse_lora). This is an experimental API. Args: components (`List[str]`): List of LoRA-injectable components to unfuse LoRA from. unfuse_transformer (`bool`, defaults to `True`): Whether to unfuse the UNet LoRA parameters. rNrbrrs rQr#AuraFlowLoraLoaderMixin.unfuse_lorar 5 5 t"/!-1 - I- -  -  S * - - `4A.2Q=d3i==rSrEc\^\rSrSrSrSS/r\r\r /SQr \ \ S-S\ \\\\R"44S\4S jj55rS.S\ \\\\R"44S \\S \4S jjr\ S/S \4Sjj5r\ S.S\\\R"44Sjj5r\ S0S \4Sjj5r\ S1S\ \\R44S\\\ \R6R8\R"44S\\\R6R84S\S\S\S\4Sjj5rS/SSS 4S\\S\ S\S\\\4U4Sjjjr!SS/4S\\4U4S jjjr"S-U4S!jjr#\ S2S\R6R8S\4S"jj5r$\ S#5r%\&S3S$S%S&S'S(\SS)4S*jj5r'\&S4S+j5r(S,r)U=r*$)5FluxLoraLoaderMixiniz Load LoRA layers into [`FluxTransformer2DModel`], [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel). Specific to [`StableDiffusion3Pipeline`]. r.r,)norm_qnorm_k norm_added_q norm_added_kFrW return_alphasc URSS5nURSS5nURSS5nURSS5nURSS5nURSS5n URS S5n URS S5n URS S5n URS S5n SnU cS n S nSSS.n[UU U UUUUUU U UUS9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnn[SU55nU(a[ U5nURUUSUU S9$[SU55nU(a[U5nURUUSUU S9$[SU55nU(a[U5nURUUSUU S9$[SU55nU(a[U5nURUUSUU S9$[UR55n0nUHnSU;dM URU5n[R"U5(a[R "U5(d[#U[$5(aURU5UU'M}['SUS35e U(dU (aURUUUUU S9$U$s snnf); Return state dict for lora weights and the network alphas. We support loading A1111 formatted LoRA checkpoints in a limited capacity. This function is experimental and might change in the future. Parameters: pretrained_model_name_or_path_or_dict (`str` or `os.PathLike` or `dict`): Can be either: - A string, the *model id* (for example `google/ddpm-celebahq-256`) of a pretrained model hosted on the Hub. - A path to a *directory* (for example `./my_model_directory`) containing the model weights saved with [`ModelMixin.save_pretrained`]. - A [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict). cache_dir (`Union[str, os.PathLike]`, *optional*): Path to a directory where a downloaded pretrained model configuration is cached if the standard cache is not used. force_download (`bool`, *optional*, defaults to `False`): Whether or not to force the (re-)download of the model weights and configuration files, overriding the cached versions if they exist. proxies (`Dict[str, str]`, *optional*): A dictionary of proxy servers to use by protocol or endpoint, for example, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. The proxies are used on each request. local_files_only (`bool`, *optional*, defaults to `False`): Whether to only load local model weights and configuration files or not. If set to `True`, the model won't be downloaded from the Hub. token (`str` or *bool*, *optional*): The token to use as HTTP bearer authorization for remote files. If `True`, the token generated from `diffusers-cli login` (stored in `~/.huggingface`) is used. revision (`str`, *optional*, defaults to `"main"`): The specific model version to use. It can be a branch name, a tag name, a commit id, or any identifier allowed by Git. subfolder (`str`, *optional*, defaults to `""`): The subfolder location of a model file within a larger model repository on the Hub or locally. return_lora_metadata (`bool`, *optional*, defaults to False): When enabled, additionally return the LoRA adapter metadata, typically found in the state dict. rNrFrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrf6FluxLoraLoaderMixin.lora_state_dict..rrirrc3,# UH nSU;v M g7f)z.lora_down.weightNrbrs rQrfrmsDA*a/ri)rmalphasrireturn_metadatac3,# UH nSU;v M g7f) processorNrbrs rQrfrms<A{a'ric3,# UH nSU;v M g7f)zquery_norm.scaleNrbrs rQrfrmsIj/14jric3,# UH nSU;v M g7f) base_modelNrbrs rQrfrmsC 1\Q. rialphazThe alpha key (zU) seems to be incorrect. If you think this error is unexpected, please open as issue.)rprrrrrr_prepare_outputsr'rrlistrwgetrE is_tensoris_floating_pointrrrrA)rrWrirrrrrrrrrrr^rrrrmrrrris_kohyais_xlabsis_bfl_controlis_fal_kontextrwrl alpha_values rQru#FluxLoraLoaderMixin.lora_state_dictsMpJJ{D1 $4e<**Y-!::&8$? 7D)::j$/JJ{D1 jj5  **%6=%zz*@%H  ""OL#7iP 02W#+-)!%  H!$#Jz#J J {H NN8 $+5+;+;+=W+=41aUVAV$!Q$+=JWDDD >zJJ''!+ 4 ( <<< >zJJ''!+ 4 ( IjII DZPJ''!+ 4 ( C CC ? KJ''!+ 4 ( JOO%&A!|(nnQ/ OOK00U5L5L[5Y5Y^h__)3q(9N1%$)!-BC 0''!%+ 4 (  UXs  K".K"NrXrYc ^^ [(d [S5eURS[5nU(a[ SS5(d [S5e[ U[ 5(aUR5nSUS'TR"U4SS0UD6upgn[S UR555n [U4S jUR555n U (dU (d [S 5e[UR55V s0sHAn U RTRS 35(dM(S U ;dM0XRU 5_MC n n [UR55V ^ s0sH`m T RTRS 35(dM([U 4SjTR55(dMNT URT 5_Mb n n [!TS5(d[#TTR5O TR$nSn['U 5S:aTR)XU 5nU(a[*R-S5 ['U 5S:a.TR/XS9n U Hm UR1T U T 05 M TR3UUUUUTUUS9 ['U 5S:aTR5U USS9UlTR9UUTR:TR<TR>UUTUUS9 gs sn fs sn f)a Load LoRA weights specified in `pretrained_model_name_or_path_or_dict` into `self.transformer` and `self.text_encoder`. All kwargs are forwarded to `self.lora_state_dict`. See [`~loaders.StableDiffusionLoraLoaderMixin.lora_state_dict`] for more details on how the state dict is loaded. See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_into_transformer`] for more details on how the state dict is loaded into `self.transformer`. Parameters: pretrained_model_name_or_path_or_dict (`str` or `os.PathLike` or `dict`): See [`~loaders.StableDiffusionLoraLoaderMixin.lora_state_dict`]. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): `Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. kwargs (`dict`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.lora_state_dict`]. r[r\r)r*r]Tr^ric3,# UH nSU;v M g7fr`rbrcs rQrf8FluxLoraLoaderMixin.load_lora_weights..msG5FcFcM5Fric3T># UHnTRH o"U;v M M g7fN!_control_lora_supported_norm_keys)rdrenorm_keyr~s rQrfrps& '8IoIoXOIoO'8%(rjrrac3,># UH oT;v M g7frrb)rdrrs rQrfrsY2XhM2Xsr.FraThe LoRA weights contain parameters that have different shapes that expected by the transformer. As a result, the state_dict of the transformer has been expanded to match the LoRA parameter shapes. To get a comprehensive list of parameter names that were modified, enable debug logging.)r.ru)rlr.rXrmrnr\rY)r.discard_original_layersr N) r rArprqrrrrsrtrurrwrxrr1ryrrDryr.len/_maybe_expand_transformer_param_shape_or_error_rr_maybe_expand_lora_state_dictrr0_load_norm_into_transformer_transformer_norm_layersr{r,r|ro)r~rWrXrYrr\rrlrm has_lora_keys has_norm_keysrtransformer_lora_state_dicttransformer_norm_state_dictr.has_param_with_expanded_shapes` ` rQr%FluxLoraLoaderMixin.load_lora_weights9s,B HI I"JJ':<[\ _T8%D%DD  ;T B B4Y4^4^4` 1*.%&/3/C/C 10 AE0 IO0 , HGZ__5FGG  '1'8  78 8*//+,' ,||t445Q78 !=Cq[ !A~~a , $' *//+,' ,||t445Q78 !Y$2X2XYY !Az~~a , $' CJ$P]B^B^gdD$9$9:dhdtdt (-% * +a /,0,`,`:U- ) ) KKk  * +a /*.*L*L'+M+ '1!!1&A!&D"EF1 '' )#%/ (  * +a /373S3S+'(-4T4K 0 (( )**))%/ ) e' ' s$ 'K;6K;>K;1'L"LLc U(a[SS5(d [S5e[RSURS35 UR UUUUUUUS9 g)a This will load the LoRA layers specified in `state_dict` into `transformer`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. network_alphas (`Dict[str, float]`): The value of the network alpha used for stable learning and preventing underflow. This value has the same meaning as the `--network_alpha` option in the kohya-ss trainer script. Refer to [this link](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning). transformer (`FluxTransformer2DModel`): The Transformer model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r)r*r]rrr5Nr6 rrrlr.rXrmrnr\rYs rQr0.FluxLoraLoaderMixin.load_lora_into_transformersmL _T8%D%DD   hs334A67%% )%/ & rSreturnc.^U=(d TRn[UR55HBnURS5SU:XdMUR U5XR US35'MD UR 5n[UR55n[UR55n[X- 5n U (a[RSU S35 U HnUR U5 M 0n U(d+UR5HnXeR5X'M [RS5 URUSS9n [U SS5n U (a)[U4SjU 55(a[S U S 35eU $) NrrzUnsupported keys found in state dict when trying to load normalization layers into the transformer. The following keys will be ignored: aWThe provided state dict contains normalization layers in addition to LoRA layers. The normalization layers will directly update the state_dict of the transformer as opposed to the LoRA layers that will co-exist separately until the "fuse_lora()" method is called. That is to say, the normalization layers will always be directly fused into the transformer and can only be unfused if `discard_original_layers=True` is passed. This might also have implications when dealing with multiple LoRAs. If you notice something unexpected, please open an issue: https://github.com/huggingface/diffusers/issues.Fstrictunexpected_keysc3T># UHnTRH o"U;v M M g7frr)rdrrrs rQrfBFluxLoraLoaderMixin._load_norm_into_transformer.. s"p/Q#JoJohq=Jo=/rzFound zJ as unexpected keys while trying to load norm layers into the transformer.)r1rxrwsplitrp removeprefixrsetrrclonerload_state_dictryrrA) rrr.rrretransformer_state_dicttransformer_keysstate_dict_keys extra_keysoverwritten_layers_state_dictincompatible_keysrs ` rQr/FluxLoraLoaderMixin._load_norm_into_transformers/3// )*Cyy~a F*=G^^C=P ++vhaL9:+ "-!7!7!95::<=joo/0/<=  NN\]g\hhij C NN3 )+%&!(5K5P5V5V5X-2)   y (77 57Q!"35FM p/ppp _--wx-,rSrc >[UUUUUURUU UUU S9 grrrs rQr{/FluxLoraLoaderMixin.load_lora_into_text_encoder# rrSrr;rrrrrc 0n 0n U(dU(d [S5eU(a*U RURX R55 U(a*U RURX0R55 U(a$U R[ XR55 U (a$U R[ XR55 UR U UUUUUU S9 g)u Save the LoRA parameters corresponding to the UNet and text encoder. Arguments: save_directory (`str` or `os.PathLike`): Directory to save LoRA parameters to. Will be created if it doesn't exist. transformer_lora_layers (`Dict[str, torch.nn.Module]` or `Dict[str, torch.Tensor]`): State dict of the LoRA layers corresponding to the `transformer`. text_encoder_lora_layers (`Dict[str, torch.nn.Module]` or `Dict[str, torch.Tensor]`): State dict of the LoRA layers corresponding to the `text_encoder`. Must explicitly pass the text encoder LoRA state dict because it comes from 🤗 Transformers. is_main_process (`bool`, *optional*, defaults to `True`): Whether the process calling this is the main process or not. Useful during distributed training and you need to call this function on all processes. In this case, set `is_main_process=True` only on the main process to avoid race conditions. save_function (`Callable`): The function to use to save the state dictionary. Useful during distributed training when you need to replace `torch.save` with another method. Can be configured with the environment variable `DIFFUSERS_SAVE_MODE`. safe_serialization (`bool`, *optional*, defaults to `True`): Whether to save the model using `safetensors` or the traditional PyTorch way with `pickle`. transformer_lora_adapter_metadata: LoRA adapter metadata associated with the transformer to be serialized with the state dict. text_encoder_lora_adapter_metadata: LoRA adapter metadata associated with the text encoder to be serialized with the state dict. zWYou must pass at least one of `transformer_lora_layers` and `text_encoder_lora_layers`.rN)rArrr1r|rr) rrr;rrrrrr=rrrs rQr%FluxLoraLoaderMixin.save_lora_weights^ sP "'+Cvw w "   c../FH\H\] ^ #   c../GI^I^_ ` , ! ( (&'HJ^J^_  . ! ( (&'IK`K`a  !)+#'1"7  rSrrorrc l>[US5(d[XR5O URn[US5(a[[ UR [ 5(a<[UR R55S:a[RS5 [TU]0"SUUUUS.UD6 g)rr.rraThe provided state dict contains normalization layers in addition to LoRA layers. The normalization layers will be directly updated the state_dict of the transformer as opposed to the LoRA layers that will co-exist separately until the 'fuse_lora()' method is called. That is to say, the normalization layers will always be directly fused into the transformer and can only be unfused if `discard_original_layers=True` is passed.rNrb) rDryr1r.rrrrsrrwrrrr)r~rrorrrr.r?s rQrFluxLoraLoaderMixin.fuse_lora sPCJ$P]B^B^gd$9$9:dhdtdt K!; < <;??FFK88==?@1D KKr   !!#'    rSc >[US5(d[XR5O URn[US5(a+UR(aUR URSS9 [ TU]"SSU0UD6 g)a, Reverses the effect of [`pipe.fuse_lora()`](https://huggingface.co/docs/diffusers/main/en/api/loaders#diffusers.loaders.LoraBaseMixin.fuse_lora). This is an experimental API. Args: components (`List[str]`): List of LoRA-injectable components to unfuse LoRA from. r.rFrrNrb)rDryr1r.rrrr)r~rrr.r?s rQrFluxLoraLoaderMixin.unfuse_lora srCJ$P]B^B^gd$9$9:dhdtdt ; : ; ; @d@d  ' ' (L(LUZ ' [ [TU]5 [US5(d[XR5O UR n[US5(a2UR (a!URUR SS9 SUlU(Ga?[USS5Gb/URn[5nUH<nURS5(dMURURSS55 M> UR5GHupg[U[R R"5(dM1Xd;dM8UR$R&nUR(bUR(R&OSn U SLn UR+S 5upn UR-U 5nX6S3nUR.S UR.S nn[R0"S 5 [R R#UUU UR2S 9nSSS5 SU0nU bUR5SX6S305 WRUSSS9 [7XU5 AU [8;dGMT[8U n[;UR.S 5n[UR<U5n[7UR<UU5 [>RASUSUSUS 35 GM ggg!,(df  N=f)a Unloads the LoRA parameters. Args: reset_to_overwritten_params (`bool`, defaults to `False`): Whether to reset the LoRA-loaded modules to their original params. Refer to the [Flux documentation](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux) to learn more. Examples: ```python >>> # Assuming `pipeline` is already loaded with the LoRA parameters. >>> pipeline.unload_lora_weights() >>> ... ``` r.rFrN_overwritten_params.weightrrrmetabiasr;r>r.biasT)assignrSet the  attribute of the model to  from )!runload_lora_weightsrDryr1r.rrrrendswithaddreplace named_modulesrrrErLinearr>rIr rpartition get_submoduleshaperBr;rsetattr"_MODULE_NAME_TO_ATTRIBUTE_MAP_FLUXintr rr)r~reset_to_overwritten_paramsr.overwritten_params module_names param_namenamerKrP module_biasrparent_module_name_current_module_name parent_modulecurrent_param_weight in_features out_featuresoriginal_moduletmp_state_dictattribute_name new_value old_valuer?s rQr'FluxLoraLoaderMixin.unload_lora_weights s" #%BI$P]B^B^gd$9$9:dhdtdt ; : ; ; @d@d  ' ' (L(LUZ ' [37K 0 &7;@UW[+\+h!,!@!@ 5L0 &&y11 $$Z%7%7 2%FG1!, 9 9 ; fehhoo664;O$*MM$6$6M6&+>$/$=$=>P$QM+=g>N+O(0D0J0J10MOcOiOijkOlKf-*/((//'(!%"/"5"5 +:+.'/0D%EN".&--v7IFRW.7Y.Z[#33N4X\3]MP&*.PP)KL_)`$'(<(B(B1(E$F $+K,>,>$O  2 2NIN &~&66QR[Q\\bclbmmnoA!<,i &&.-s +K  K c 0nUbURU5 UbURU5 U=(d URn[UR55HBnUR S5SU:XdMUR U5XVR US35'MD Sn0n[USS5SLn [US5n UR5GHup[U [RR5(dM1U RRn U R bU R ROSnUSLnU (aU R#SS5OU nUS 3nUS 3nUU;aMUUR$S nUUR$SnUR'XS 9n[)U5UU4:XaMUunnSnUU:aUS U SUSU3- nUU:a USUSUS3- nOUS- nU(a[*R-U5 UU:d UU:dGMASnU R/S5unnnUR1U5nU (a [3X5n [R4"S5 [RRUUXR6S9nSSS5 [R8"WRRU R4U R6S9n[)SU55nU UU'SU0n UbUU S'UR;U SSS9 [=UUU5 A U[>;a[>Un![AURRR$S 5n"[URBU!5n#[=URBU!U"5 [*RESU!SU"SU#S35 XUS3'UcGMXUS3'GM [GU5S:aXl$U$!,(df  GNJ=f)z Control LoRA expands the shape of the input layer from (3072, 64) to (3072, 128). This method handles that and generalizes things a bit so that any parameter that needs expansion receives appropriate treatment. NrrF peft_config hf_quantizerz .base_layerr.lora_A.weight.lora_B.weightr)rJ base_modulez:Expanding the nn.Linear input/output features for module="z" because the provided LoRA checkpoint contains higher number of features than expected. The number of input_features will be expanded from z to z:, and the number of output features will be expanded from Trr)rBr;c3:# UHn[SU5v M g7f)rN)slice)rddims rQrfVFluxLoraLoaderMixin._maybe_expand_transformer_param_shape_or_error_.. s"Pr)rrrrrrr)%rr1rxrwrrprryrDrrrrErrr>rIrrr_calculate_module_shapetuplerdebugrrrRrBr; zeros_likerrrrr rrr)$rr.runorm_state_dictrrrehas_param_with_shape_updateris_peft_loaded is_quantizedrrKrPrrlora_base_namelora_A_weight_namelora_B_weight_namerrmodule_weight_shapemodule_out_featuresmodule_in_features debug_messagerrrrexpanded_module new_weightslicesrrrrs$ rQrCFluxLoraLoaderMixin._maybe_expand_transformer_param_shape_or_error_< s+  &   o .  &   o ./3// )*Cyy~a F*=G^^C=P ++vhaL9:+ ',# mTB$N{N; '557LD&%((//22 & 2 2 28++2Ifkk..t "$.DRmR!@X\(6'7~%F"(6'7~%F"%Z7();<BB1E )*<=CCAF '*&A&A &A&h#,-, 1LL:M7#%7 " !33!TUYTZ[));(&+>$/$=$=>P$QM#(RS^(g f-*/((//'DH[H[+:+."'!1!1'..33MP&*.PP)KL_)`$'(>(>(C(C(I(I!(L$M $+K,>,>$O  2 2NIN &~&66QR[Q\\bclbmmnoKX*=)>g'FG".LW.A-B%+HIo8r ! "Q &.@ +**S.-s *O  O c[5nUR5nURS3nUVs/sH)ofRS5(dMUS[ S5*PM+ nnUVs/sH(oR U5(dMU[ U5SPM* nn[ [U55n[ UR5VV s1sHupUiM sn n5n [U5[U 5- n U (a[RSU S35 UGH3n X;aM U RUS5S3U;aU RUS5S3OU RUS5S3n XMnX%U S3nURXS9nUS URS :aURS URS 4n[R"UURS 9nUSS2SURS 24R!U5 UX%U S3'UR#U 5 GMUS URS :dGM[%S U S URS35e U(a&[R'SURSUS35 U$s snfs snfs sn nf)NrrzFound unexpected modules: z. These will be ignored.rz.base_layer.weightr)rJbase_weight_param_namerrrBzThis LoRA param (z*.lora_A.weight) has an incompatible shape zk. Please open an issue to file for a feature request - https://github.com/huggingface/diffusers/issues/new.zGThe following LoRA modules were zero padded to match the state dict of z: zn. Please open an issue if you think this was unexpected - https://github.com/huggingface/diffusers/issues/new.)rrr1rrrsortedrrrrrrrEzerosrBcopy_rNotImplementedErrorr)rr.ruexpanded_module_namesrrrelora_module_namesrrtransformer_module_namesunexpected_modulesrbase_param_namebase_weight_param lora_A_parambase_module_shaperexpanded_state_dict_weights rQr1FluxLoraLoaderMixin._maybe_expand_lora_state_dict s #!,!7!7!9(()+6E 5Dc UeHf )C(3'(( )_  >Oj=NTRaRabhRi0T#f+-0=Nj"3'8#9:#){?X?X?Z*[?ZGD4?Z*[#\  !23c:R6SS  LL56H5IIab c"A&ii+,,>?CYY99VR());< &"-.g6  !7 G *XaS+GHL!$ ; ;+ ; v  #l&8&8&;;%++A.0A0G0G0JK-2[[GXG_G_-`**1.E 0B0B10E.E+EFLL\Z@Z(1#^ <=%))!,"1% (:(:1(==)'s*TUaUgUgThiTU-#4 ! KKYZ]ZnZnYooqsHrIIwx S k*[sI7 I7$I<I<J rJztorch.nn.Modulerztorch.nn.Linearrz torch.Sizec"S[R4SjnUbU"UR5$UbXURS5(d[ SU<S35eUR SS5Sn[ X5nU"UR5$[ S5e) Nr>cURRS:XaURR$URRS:Xa UR$UR$)Nr4r6)r?r@rHr quant_shape)r>s rQ_get_weight_shapeFFluxLoraLoaderMixin._calculate_module_shape.._get_weight_shape sR((L8))///!!**o=)))||#rSrzaInvalid `base_weight_param_name` passed as it does not end with '.weight' base_weight_param_name=rrrzBEither `base_module` or `base_weight_param_name` must be provided.)rErr>rrArsplitr )rJrrr module_path submodules rQr+FluxLoraLoaderMixin._calculate_module_shape s  $ell $  "$[%7%78 8 # /)229== xaw`yyz{177 1EaHK-eAI$Y%5%56 6]^^rScU/nU(aURU5 U(aURU5 U(dU(a [U5$U$r)appendr)rrmrorirpoutputss rQrw$FluxLoraLoaderMixin._prepare_outputs s:,  NN6 "  NN8 $"/?uW~SSrSrb)FrNNNFFrr)NNN)NN)NFF)+r@rrrrrrCr1rr|rrrrrrrErrrurrr0rr{rrrrrrrrrrrrr staticmethodrrwrrrs@rQrdrds<,^<')(\%$d/4S$sELL?P:Q5Q/RdddR'+ { /4S$sELL?P:Q5Q/R{ sm{  { z 4 4 4 l  % 3- c5<< 3-3-j7 7 7 r TX?C $"&#'*.+/E c2;;./E "&c5%,,1N+O&O!PE #'sEHHOO';"< E  E  E  E !E E R"/!-1 : I: :  :  S * : : x4A.2Q=d3i==*BH y+XX__y+  y+y+v..`*.&*_ _&_!$_  __4TTrSrdc6\rSrSrSS/r\r\r\ SS\ 4Sjj5r \ SS\ 4Sjj5r \ SS\ \\R 4S \\\R&R(4S \\\R&R(4S \ S \S \S\ 4Sjj5rSrg)AmusedLoraLoaderMixini r.r,NrYc U(a[SS5(d [S5e[RSURS35 UR UUUUUUUS9 g)a This will load the LoRA layers specified in `state_dict` into `transformer`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. network_alphas (`Dict[str, float]`): The value of the network alpha used for stable learning and preventing underflow. This value has the same meaning as the `--network_alpha` option in the kohya-ss trainer script. Refer to [this link](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning). transformer (`UVit2DModel`): The Transformer model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r)r*r]rrr5Nr6rs rQr00AmusedLoraLoaderMixin.load_lora_into_transformer smN _T8%D%DD   hs334A67%% )%/ & rSc >[UUUUUURUU UUU S9 grrrs rQr{1AmusedLoraLoaderMixin.load_lora_into_text_encoderM rrSrrr;rrrrc &0nU(dU(d [S5eU(a*URURX0R55 U(a*URURX R55 UR UUUUUUS9 g)un Save the LoRA parameters corresponding to the UNet and text encoder. Arguments: save_directory (`str` or `os.PathLike`): Directory to save LoRA parameters to. Will be created if it doesn't exist. unet_lora_layers (`Dict[str, torch.nn.Module]` or `Dict[str, torch.Tensor]`): State dict of the LoRA layers corresponding to the `unet`. text_encoder_lora_layers (`Dict[str, torch.nn.Module]` or `Dict[str, torch.Tensor]`): State dict of the LoRA layers corresponding to the `text_encoder`. Must explicitly pass the text encoder LoRA state dict because it comes from 🤗 Transformers. is_main_process (`bool`, *optional*, defaults to `True`): Whether the process calling this is the main process or not. Useful during distributed training and you need to call this function on all processes. In this case, set `is_main_process=True` only on the main process to avoid race conditions. save_function (`Callable`): The function to use to save the state dictionary. Useful during distributed training when you need to replace `torch.save` with another method. Can be configured with the environment variable `DIFFUSERS_SAVE_MODE`. safe_serialization (`bool`, *optional*, defaults to `True`): Whether to save the model using `safetensors` or the traditional PyTorch way with `pickle`. zVYou must pass at least one of `transformer_lora_layers` or `text_encoder_lora_layers`.)rrrrrrN)rArrr1r|r) rrrr;rrrrrs rQr'AmusedLoraLoaderMixin.save_lora_weights sB '+Cuv v "   c../FH\H\] ^ #   c../GI^I^_ ` !)+#'1  rSrbrr)NNTNNT)r@rrrrrCr1rr|rrr0r{rrrrrrErrrrrrbrSrQrr s+^<')4 4 4 l7 7 7 r@D>B $"&#'3 c2;;./3 #'sEHHOO';"<3 "&c588??&:!; 3  3  3  3 !3 3 rSrc^\rSrSrSrS/r\r\\ S\ \ \ \ \ R444Sj55rSS\ \ \ \ \ R44S\\ S \4S jjr\SS \4S jj5r\SS \ \ \R*4S \ \ \ \ R,R.\ R44S\S\ S\S\S\\4Sjj5rS/SSS4S\\ S\S\S\\\ 4U4SjjjrS/4S\\ 4U4SjjjrSrU=r $)CogVideoXLoraLoaderMixini z[ Load LoRA layers into [`CogVideoXTransformer3DModel`]. Specific to [`CogVideoXPipeline`]. r.rWc URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnnU (aUU4nU$UnU$s snnf)r#rNrFrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrf;CogVideoXLoraLoaderMixin.lora_state_dict..! rrirrr&r's rQru(CogVideoXLoraLoaderMixin.lora_state_dict rJr)NFrXrYc [(d [S5eURS[5nU(a[ SS5(a [S5e[ U[ 5(aUR5nSUS'UR"U40UD6upg[SUR555nU(d [S 5eURU[US 5(d[XR5O URUUUUUS 9 g ) rLr[r\r+r,r]Tr^c3,# UH nSU;v M g7fr`rbrcs rQrf=CogVideoXLoraLoaderMixin.load_lora_weights..W rhrirjr.r/NrOr2s rQr*CogVideoXLoraLoaderMixin.load_lora_weights* rQrSc U(a[SS5(a [S5e[RSURS35 UR USUUUUUS9 g)ad This will load the LoRA layers specified in `state_dict` into `transformer`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. transformer (`CogVideoXTransformer3DModel`): The Transformer model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r+r,r]rrNr5r6r7s rQr03CogVideoXLoraLoaderMixin.load_lora_into_transformere rTrSrr;rrrrr=c 0n0n U(d [S5eURURX R55 Ub$U R[ XpR55 UR UUUUUUU S9 grVrWrXs rQr*CogVideoXLoraLoaderMixin.save_lora_weights rZrSrrrorrc 0>[TU]"SUUUUS.UD6 grrrs rQr"CogVideoXLoraLoaderMixin.fuse_lora rrSc *>[TU]"SSU0UD6 gr^rrs rQr$CogVideoXLoraLoaderMixin.unfuse_lora r`rSrbrrrarbrs@rQr'r' s,_'^/4S$sELL?P:Q5Q/R^^F'+ 9 /4S$sELL?P:Q5Q/R9 sm9  9 v / / / b TX $"&#'<@5 c2;;./5 "&c5%,,1N+O&O!P5  5  5  5 !5 ,4D>5 5 r"/!-1 - I- -  -  S * - - ^4A/=d3i==rSr'c^\rSrSrSrS/r\r\\ S\ \ \ \ \ R444Sj55rSS\ \ \ \ \ R44S\\ S \4S jjr\SS \4S jj5r\SS \ \ \R*4S \ \ \ \ R,R.\ R44S\S\ S\S\S\\4Sjj5rS/SSS4S\\ S\S\S\\\ 4U4SjjjrS/4S\\ 4U4SjjjrSrU=r $)Mochi1LoraLoaderMixini zS Load LoRA layers into [`MochiTransformer3DModel`]. Specific to [`MochiPipeline`]. r.rWc URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnnU (aUU4nU$UnU$s snnf)r#rNrFrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrf8Mochi1LoraLoaderMixin.lora_state_dict..t rrirrr&r's rQru%Mochi1LoraLoaderMixin.lora_state_dict rJr)NFrXrYc [(d [S5eURS[5nU(a[ SS5(a [S5e[ U[ 5(aUR5nSUS'UR"U40UD6upg[SUR555nU(d [S 5eURU[US 5(d[XR5O URUUUUUS 9 g ) rLr[r\r+r,r]Tr^c3,# UH nSU;v M g7fr`rbrcs rQrf:Mochi1LoraLoaderMixin.load_lora_weights.. rhrirjr.r/NrOr2s rQr'Mochi1LoraLoaderMixin.load_lora_weights~ rQrSc U(a[SS5(a [S5e[RSURS35 UR USUUUUUS9 g)a` This will load the LoRA layers specified in `state_dict` into `transformer`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. transformer (`MochiTransformer3DModel`): The Transformer model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r+r,r]rrNr5r6r7s rQr00Mochi1LoraLoaderMixin.load_lora_into_transformer rTrSrr;rrrrr=c 0n0n U(d [S5eURURX R55 Ub$U R[ XpR55 UR UUUUUUU S9 grVrWrXs rQr'Mochi1LoraLoaderMixin.save_lora_weights rZrSrrrorrc 0>[TU]"SUUUUS.UD6 grrrs rQrMochi1LoraLoaderMixin.fuse_lora&rrSc *>[TU]"SSU0UD6 gr^rrs rQr!Mochi1LoraLoaderMixin.unfuse_loraVr`rSrbrrrarbrs@rQr9r9 ,_'^/4S$sELL?P:Q5Q/R^^H'+ 9 /4S$sELL?P:Q5Q/R9 sm9  9 v / / / b TX $"&#'<@5 c2;;./5 "&c5%,,1N+O&O!P5  5  5  5 !5 ,4D>5 5 t"/!-1 - I- -  -  S * - - `4A/=d3i==rSr9c^\rSrSrSrS/r\r\\ S\ \ \ \ \ R444Sj55rSS\ \ \ \ \ R44S\\ S \4S jjr\SS \4S jj5r\SS \ \ \R*4S \ \ \ \ R,R.\ R44S\S\ S\S\S\\4Sjj5rS/SSS4S\\ S\S\S\\\ 4U4SjjjrS/4S\\ 4U4SjjjrSrU=r $)LTXVideoLoraLoaderMixinihzT Load LoRA layers into [`LTXVideoTransformer3DModel`]. Specific to [`LTXPipeline`]. r.rWc URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnn[SU55nU(a [ U5nU (aUU4nU$UnU$s snnf)rkrNrFrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrf:LTXVideoLoraLoaderMixin.lora_state_dict..rrirrc3B# UHoRS5v M g7fzdiffusion_model.Nrrs rQrfrOs%[PZ1ll3E&F&FPZ)rprrrrrr#rrWrrrrrrrrrrr^rrrrmrrrris_non_diffusers_formatrs rQru'LTXVideoLoraLoaderMixin.lora_state_dictpsnJJ{D1 $4e<**Y-!::&8$? 7D)::j$/JJ{D1 jj5  **%6=%zz*@%H  ""OL#7iP 02W#+-)!%  H!$#Jz#J J {H NN8 $+5+;+;+=W+=41aUVAV$!Q$+=JW"%%[PZ%["[ "FzRJ(.rhrirjr.r/NrOr2s rQr)LTXVideoLoraLoaderMixin.load_lora_weightsrQrSc U(a[SS5(a [S5e[RSURS35 UR USUUUUUS9 g)ac This will load the LoRA layers specified in `state_dict` into `transformer`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. transformer (`LTXVideoTransformer3DModel`): The Transformer model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r+r,r]rrNr5r6r7s rQr02LTXVideoLoraLoaderMixin.load_lora_into_transformerrTrSrr;rrrrr=c 0n0n U(d [S5eURURX R55 Ub$U R[ XpR55 UR UUUUUUU S9 grVrWrXs rQr)LTXVideoLoraLoaderMixin.save_lora_weightsDrZrSrrrorrc 0>[TU]"SUUUUS.UD6 grrrs rQr!LTXVideoLoraLoaderMixin.fuse_lora~rrSc *>[TU]"SSU0UD6 gr^rrs rQr#LTXVideoLoraLoaderMixin.unfuse_lorar`rSrbrrrarbrs@rQrLrLh,_'a/4S$sELL?P:Q5Q/RaaN'+ 9 /4S$sELL?P:Q5Q/R9 sm9  9 v / / / b TX $"&#'<@5 c2;;./5 "&c5%,,1N+O&O!P5  5  5  5 !5 ,4D>5 5 t"/!-1 - I- -  -  S * - - `4A/=d3i==rSrLc^\rSrSrSrS/r\r\\ S\ \ \ \ \ R444Sj55rSS\ \ \ \ \ R44S\\ S \4S jjr\SS \4S jj5r\SS \ \ \R*4S \ \ \ \ R,R.\ R44S\S\ S\S\S\\4Sjj5rS/SSS4S\\ S\S\S\\\ 4U4SjjjrS/4S\\ 4U4SjjjrSrU=r $)SanaLoraLoaderMixinizQ Load LoRA layers into [`SanaTransformer2DModel`]. Specific to [`SanaPipeline`]. r.rWc URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnnU (aUU4nU$UnU$s snnf)r#rNrFrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrf6SanaLoraLoaderMixin.lora_state_dict.."rrirrr&r's rQru#SanaLoraLoaderMixin.lora_state_dictrJr)NFrXrYc [(d [S5eURS[5nU(a[ SS5(a [S5e[ U[ 5(aUR5nSUS'UR"U40UD6upg[SUR555nU(d [S 5eURU[US 5(d[XR5O URUUUUUS 9 g ) rLr[r\r+r,r]Tr^c3,# UH nSU;v M g7fr`rbrcs rQrf8SanaLoraLoaderMixin.load_lora_weights..Yrhrirjr.r/NrOr2s rQr%SanaLoraLoaderMixin.load_lora_weights,rQrSc U(a[SS5(a [S5e[RSURS35 UR USUUUUUS9 g)a_ This will load the LoRA layers specified in `state_dict` into `transformer`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. transformer (`SanaTransformer2DModel`): The Transformer model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r+r,r]rrNr5r6r7s rQr0.SanaLoraLoaderMixin.load_lora_into_transformergrTrSrr;rrrrr=c 0n0n U(d [S5eURURX R55 Ub$U R[ XpR55 UR UUUUUUU S9 grVrWrXs rQr%SanaLoraLoaderMixin.save_lora_weightsrZrSrrrorrc 0>[TU]"SUUUUS.UD6 grrrs rQrSanaLoraLoaderMixin.fuse_lorarrSc *>[TU]"SSU0UD6 gr^rrs rQrSanaLoraLoaderMixin.unfuse_lorar`rSrbrrrarbrs@rQrererJrSrec^\rSrSrSrS/r\r\\ S\ \ \ \ \ R444Sj55rSS\ \ \ \ \ R44S\\ S \4S jjr\SS \4S jj5r\SS \ \ \R*4S \ \ \ \ R,R.\ R44S\S\ S\S\S\\4Sjj5rS/SSS4S\\ S\S\S\\\ 4U4SjjjrS/4S\\ 4U4SjjjrSrU=r $)HunyuanVideoLoraLoaderMixiniza Load LoRA layers into [`HunyuanVideoTransformer3DModel`]. Specific to [`HunyuanVideoPipeline`]. r.rWc URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnn[SU55nU(a [ U5nU (aUU4nU$UnU$s snnf)a2 Return state dict for lora weights and the network alphas. We support loading original format HunyuanVideo LoRA checkpoints. This function is experimental and might change in the future. Parameters: pretrained_model_name_or_path_or_dict (`str` or `os.PathLike` or `dict`): Can be either: - A string, the *model id* (for example `google/ddpm-celebahq-256`) of a pretrained model hosted on the Hub. - A path to a *directory* (for example `./my_model_directory`) containing the model weights saved with [`ModelMixin.save_pretrained`]. - A [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict). cache_dir (`Union[str, os.PathLike]`, *optional*): Path to a directory where a downloaded pretrained model configuration is cached if the standard cache is not used. force_download (`bool`, *optional*, defaults to `False`): Whether or not to force the (re-)download of the model weights and configuration files, overriding the cached versions if they exist. proxies (`Dict[str, str]`, *optional*): A dictionary of proxy servers to use by protocol or endpoint, for example, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. The proxies are used on each request. local_files_only (`bool`, *optional*, defaults to `False`): Whether to only load local model weights and configuration files or not. If set to `True`, the model won't be downloaded from the Hub. token (`str` or *bool*, *optional*): The token to use as HTTP bearer authorization for remote files. If `True`, the token generated from `diffusers-cli login` (stored in `~/.huggingface`) is used. revision (`str`, *optional*, defaults to `"main"`): The specific model version to use. It can be a branch name, a tag name, a commit id, or any identifier allowed by Git. subfolder (`str`, *optional*, defaults to `""`): The subfolder location of a model file within a larger model repository on the Hub or locally. return_lora_metadata (`bool`, *optional*, defaults to False): When enabled, additionally return the LoRA adapter metadata, typically found in the state dict. rNrFrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrf>HunyuanVideoLoraLoaderMixin.lora_state_dict..vrrirrc3,# UH nSU;v M g7f) img_attn_qkvNrbrs rQrfrz|s'PZ!(;Zri)rprrrrrr)rrWrrrrrrrrrrr^rrrrmrrrris_original_hunyuan_videors rQru+HunyuanVideoLoraLoaderMixin.lora_state_dictsnJJ{D1 $4e<**Y-!::&8$? 7D)::j$/JJ{D1 jj5  **%6=%zz*@%H  ""OL#7iP 02W#+-)!%  H!$#Jz#J J {H NN8 $+5+;+;+=W+=41aUVAV$!Q$+=JW$''PZ'P$P! $A*MJ(.rhrirjr.r/NrOr2s rQr-HunyuanVideoLoraLoaderMixin.load_lora_weightsrQrSc U(a[SS5(a [S5e[RSURS35 UR USUUUUUS9 g)ag This will load the LoRA layers specified in `state_dict` into `transformer`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. transformer (`HunyuanVideoTransformer3DModel`): The Transformer model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r+r,r]rrNr5r6r7s rQr06HunyuanVideoLoraLoaderMixin.load_lora_into_transformerrTrSrr;rrrrr=c 0n0n U(d [S5eURURX R55 Ub$U R[ XpR55 UR UUUUUUU S9 grVrWrXs rQr-HunyuanVideoLoraLoaderMixin.save_lora_weightsrZrSrrrorrc 0>[TU]"SUUUUS.UD6 grrrs rQr%HunyuanVideoLoraLoaderMixin.fuse_lora,rrSc *>[TU]"SSU0UD6 gr^rrs rQr'HunyuanVideoLoraLoaderMixin.unfuse_lora\r`rSrbrrrarbrs@rQrwrwrcrSrwc^\rSrSrSrS/r\r\\ S\ \ \ \ \ R444Sj55rSS\ \ \ \ \ R44S\\ S \4S jjr\SS \4S jj5r\SS \ \ \R*4S \ \ \ \ R,R.\ R44S\S\ S\S\S\\4Sjj5rS/SSS4S\\ S\S\S\\\ 4U4SjjjrS/4S\\ 4U4SjjjrSrU=r $)Lumina2LoraLoaderMixininz_ Load LoRA layers into [`Lumina2Transformer2DModel`]. Specific to [`Lumina2Text2ImgPipeline`]. r.rWc URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnn[SU55nU(a [ U5nU (aUU4nU$UnU$s snnf)rkrNrFrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrf9Lumina2LoraLoaderMixin.lora_state_dict..rrirrc3B# UHoRS5v M g7frQrrs rQrfrsQjLL);<. rhrirjr.r/NrOr2s rQr(Lumina2LoraLoaderMixin.load_lora_weightsrQrSc U(a[SS5(a [S5e[RSURS35 UR USUUUUUS9 g)ab This will load the LoRA layers specified in `state_dict` into `transformer`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. transformer (`Lumina2Transformer2DModel`): The Transformer model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r+r,r]rrNr5r6r7s rQr01Lumina2LoraLoaderMixin.load_lora_into_transformerrTrSrr;rrrrr=c 0n0n U(d [S5eURURX R55 Ub$U R[ XpR55 UR UUUUUUU S9 grVrWrXs rQr(Lumina2LoraLoaderMixin.save_lora_weightsKrZrSrrrorrc 0>[TU]"SUUUUS.UD6 grrrs rQr Lumina2LoraLoaderMixin.fuse_lorarrSc *>[TU]"SSU0UD6 gr^rrs rQr"Lumina2LoraLoaderMixin.unfuse_lorar`rSrbrrrarbrs@rQrrns,_'b/4S$sELL?P:Q5Q/RbbP'+ 9 /4S$sELL?P:Q5Q/R9 sm9  9 v / / / b TX $"&#'<@5 c2;;./5 "&c5%,,1N+O&O!P5  5  5  5 !5 ,4D>5 5 t"/!-1 - I- -  -  S * - - `4A/=d3i==rSrc>^\rSrSrSrSS/r\r\\ S\ \ \ \ \ R444Sj55r\S\ R R"4Sj5rSS\ \ \ \ \ R44S \\ S \4S jjr\SS \4S jj5r\S S\ \ \R04S\ \ \ \ R R"\ R44S\S\ S\S\S\\4Sjj5rS/SS S4S\\ S\S\S\\\ 4U4SjjjrS/4S\\ 4U4SjjjrSr U=r!$)!WanLoraLoaderMixinizo Load LoRA layers into [`WanTransformer3DModel`]. Specific to [`WanPipeline`] and `[WanImageToVideoPipeline`]. r. transformer_2rWc (URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55(a [U5nO"[SU55(a [ U5n[SU55nU(aESn[ R U5 UR5VVs0sHunnSU;dMUU_M nnnU (aUU4nU$UnU$s snnf)rkrNrFrrrrrrrr^Trrrrc3B# UHoRS5v M g7frQrrs rQrf5WanLoraLoaderMixin.lora_state_dict..&DA||.//rRc3B# UHoRS5v M g7frNrrs rQrfr(@Zl++ZrRc3,# UH nSU;v M g7frrbrs rQrfr+rrirrrprrr&r rrrr's rQru"WanLoraLoaderMixin.lora_state_dictsnJJ{D1 $4e<**Y-!::&8$? 7D)::j$/JJ{D1 jj5  **%6=%zz*@%H  ""OL#7iP 02W#+-)!%  H DD D DEjQJ @Z@ @ @>zJJ ##Jz#J J {H NN8 $+5+;+;+=W+=41aUVAV$!Q$+=JW(.?GJq||122JrRblocks.rrrc3,# UH nSU;v M g7f add_k_projNrbrs rQrfrADAla/ric3,# UH nSU;v M g7f add_v_projNrbrs rQrfrALshrcd\]^M^hrric3,# UH nSU;v M g7f .lora_B.biasNrbrs rQrfrBC 1>Q. rik_imgv_imgrrr.attn2.to_k.lora_A.weight.attn2.to_k.lora_B.weightr.attn2.rr.attn2.to_k.lora_B.biasr r  image_dimrBrrrrangeziprErrr.r target_devicer num_blocks is_i2v_lorahas_biasiocref_key_lora_Aref_key_lora_Bref_key_lora_B_biasref_lora_B_bias_tensors rQ_maybe_expand_t2v_lora_for_i2v1WanLoraLoaderMixin._maybe_expand_t2v_lora_for_i2v4s    ' ' / #** GJG G G:h:aYbfgYgAaggi0399#>qA:hiJDDDsLshrLsIsKC CCH!!:&' 2\<4PQDA':1#=V%WN':1#=V%WN%7>;[ TYTdTd"%8;T#UV_lUJ!4QCwqcPQUZTdTd"%8;T#UV_lUJ!4QCwqcPQ-@sBY*Z'x$7$E1;1P.V[VfVf2#0W %871#\#RS+R'6Ei  F*FNFrXrYc f[(d [S5eURS[5nU(a[ SS5(a [S5e[ U[ 5(aUR5nSUS'UR"U40UD6upgUR[US5(d[XR5O URUS 9n[S UR555nU(d [S 5eURS S 5n U (aS[US5(d"[!S[#U5R$S35eUR'UUR(UUUUUS9 gUR'U[US5(d[XR5O URUUUUUS9 g)rLr[r\r+r,r]Tr^r.r.rc3,# UH nSU;v M g7fr`rbrcs rQrf7WanLoraLoaderMixin.load_lora_weights..rhrirjload_into_transformer_2Fr'' object has no attribute transformer_2Note that Wan2.1 models do not have a transformer_2 component.Ensure the model has a transformer_2 component before setting load_into_transformer_2=True.r/Nr rArprqrrrrsrtrurrDryr1r.rvrwAttributeErrorrCr@r0r r~rWrXrYrr\rrmrrs rQr$WanLoraLoaderMixin.load_lora_weightsd8 HI I"JJ':<[\ h!?!?D  ;T B B4Y4^4^4` 1*.%&#334Yd]cd 88DKDR_D`D`&;&;[TU]"SUUUUS.UD6 grrrs rQrWanLoraLoaderMixin.fuse_lora$rrSc *>[TU]"SSU0UD6 gr^rrs rQrWanLoraLoaderMixin.unfuse_loraTr`rSrbrrra"r@rrrrrrCr1rrrrrrErrurrrrrrr0rrrrsrrrrrrrrs@rQrrs,_='a/4S$sELL?P:Q5Q/RaaF-XX__--d'+ Q/4S$sELL?P:Q5Q/RQsmQ Qf / / / b TX $"&#'<@5 c2;;./5 "&c5%,,1N+O&O!P5  5  5  5 !5 ,4D>5 5 t"/!-1 - I- -  -  S * - - `4A/=d3i==rSrc<^\rSrSrSrS/r\r\\ S\ \ \ \ \ R444Sj55r\S\ R R"4Sj5rSS\ \ \ \ \ R44S \\ S \4S jjr\SS \4S jj5r\SS \ \ \R04S\ \ \ \ R R"\ R44S\S\ S\S\S\\4Sjj5rS/SSS4S\\ S\S\S\\\ 4U4SjjjrS/4S\\ 4U4SjjjrSr U=r!$) SkyReelsV2LoraLoaderMixinifz9 Load LoRA layers into [`SkyReelsV2Transformer3DModel`]. r.rWc (URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55(a [U5nO"[SU55(a [ U5n[SU55nU(aESn[ R U5 UR5VVs0sHunnSU;dMUU_M nnnU (aUU4nU$UnU$s snnf)rkrNrFrrrrrrrr^Trrrrc3B# UHoRS5v M g7frQrrs rQrf.rrRc3B# UHoRS5v M g7frrrs rQrfrrrRc3,# UH nSU;v M g7frrbrs rQrfrrrirrrr's rQru)SkyReelsV2LoraLoaderMixin.lora_state_dictnspJJ{D1 $4e<**Y-!::&8$? 7D)::j$/JJ{D1 jj5  **%6=%zz*@%H  ""OL#7iP 02W#+-)!%  H DD D DEjQJ @Z@ @ @>zJJ ##Jz#J J {H NN8 $+5+;+;+=W+=41aUVAV$!Q$+=JW(.rrRrrrrc3,# UH nSU;v M g7frrbrs rQrfrrric3,# UH nSU;v M g7frrbrs rQrfrrric3,# UH nSU;v M g7frrbrs rQrfrrrirrrrrrrrrrrrrrrs rQr8SkyReelsV2LoraLoaderMixin._maybe_expand_t2v_lora_for_i2vs    ' ' / #** GJG G G:h:aYbfgYgAaggi0399#>qA:hiJDDDsLshrLsIsKC CCH!!:&' 2\<4PQDA':1#=V%WN':1#=V%WN%7>;[ TYTdTd"%8;T#UV_lUJ!4QCwqcPQUZTdTd"%8;T#UV_lUJ!4QCwqcPQ-@sBY*Z'x$7$E1;1P.V[VfVf2#0W %871#\#RS+R'6EirNFrXrYc f[(d [S5eURS[5nU(a[ SS5(a [S5e[ U[ 5(aUR5nSUS'UR"U40UD6upgUR[US5(d[XR5O URUS 9n[S UR555nU(d [S 5eURS S 5n U (aS[US5(d"[!S[#U5R$S35eUR'UUR(UUUUUS9 gUR'U[US5(d[XR5O URUUUUUS9 g)rLr[r\r+r,r]Tr^r.rc3,# UH nSU;v M g7fr`rbrcs rQrf>SkyReelsV2LoraLoaderMixin.load_lora_weights..7rhrirjrFrrrr/Nrrs rQr+SkyReelsV2LoraLoaderMixin.load_lora_weightsrrSc U(a[SS5(a [S5e[RSURS35 UR USUUUUUS9 g)ae This will load the LoRA layers specified in `state_dict` into `transformer`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. transformer (`SkyReelsV2Transformer3DModel`): The Transformer model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r+r,r]rrNr5r6r7s rQr04SkyReelsV2LoraLoaderMixin.load_lora_into_transformerYrTrSrr;rrrrr=c 0n0n U(d [S5eURURX R55 Ub$U R[ XpR55 UR UUUUUUU S9 grVrWrXs rQr+SkyReelsV2LoraLoaderMixin.save_lora_weightsrZrSrrrorrc 0>[TU]"SUUUUS.UD6 grrrs rQr#SkyReelsV2LoraLoaderMixin.fuse_lorarrSc *>[TU]"SSU0UD6 gr^rrs rQr%SkyReelsV2LoraLoaderMixin.unfuse_lorar`rSrbrrrarrs@rQrrfs,_'a/4S$sELL?P:Q5Q/RaaF-XX__--f'+ Q/4S$sELL?P:Q5Q/RQsmQ Qf / / / b TX $"&#'<@5 c2;;./5 "&c5%,,1N+O&O!P5  5  5  5 !5 ,4D>5 5 t"/!-1 - I- -  -  S * - - `4A/=d3i==rSrc^\rSrSrSrS/r\r\\ S\ \ \ \ \ R444Sj55rSS\ \ \ \ \ R44S\\ S \4S jjr\SS \4S jj5r\SS \ \ \R*4S \ \ \ \ R,R.\ R44S\S\ S\S\S\\4Sjj5rS/SSS4S\\ S\S\S\\\ 4U4SjjjrS/4S\\ 4U4SjjjrSrU=r $)CogView4LoraLoaderMixinizT Load LoRA layers into [`WanTransformer3DModel`]. Specific to [`CogView4Pipeline`]. r.rWc URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnnU (aUU4nU$UnU$s snnf)r#rNrFrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrf:CogView4LoraLoaderMixin.lora_state_dict..jrrirrr&r's rQru'CogView4LoraLoaderMixin.lora_state_dictrJr)NFrXrYc [(d [S5eURS[5nU(a[ SS5(a [S5e[ U[ 5(aUR5nSUS'UR"U40UD6upg[SUR555nU(d [S 5eURU[US 5(d[XR5O URUUUUUS 9 g ) rLr[r\r+r,r]Tr^c3,# UH nSU;v M g7fr`rbrcs rQrf.rhrirjr.r/NrOr2s rQr)CogView4LoraLoaderMixin.load_lora_weightstrQrSc U(a[SS5(a [S5e[RSURS35 UR USUUUUUS9 g)ac This will load the LoRA layers specified in `state_dict` into `transformer`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. transformer (`CogView4Transformer2DModel`): The Transformer model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r+r,r]rrNr5r6r7s rQr02CogView4LoraLoaderMixin.load_lora_into_transformerrTrSrr;rrrrr=c 0n0n U(d [S5eURURX R55 Ub$U R[ XpR55 UR UUUUUUU S9 grVrWrXs rQr)CogView4LoraLoaderMixin.save_lora_weightsrZrSrrrorrc 0>[TU]"SUUUUS.UD6 grrrs rQr!CogView4LoraLoaderMixin.fuse_lorarrSc *>[TU]"SSU0UD6 gr^rrs rQr#CogView4LoraLoaderMixin.unfuse_loraLr`rSrbrrrarbrs@rQr r rJrSr c^\rSrSrSrS/r\r\\ S\ \ \ \ \ R444Sj55rSS\ \ \ \ \ R44S\\ S \4S jjr\SS \4S jj5r\SS \ \ \R*4S \ \ \ \ R,R.\ R44S\S\ S\S\S\\4Sjj5rS/SSS4S\\ S\S\S\\\ 4U4SjjjrS/4S\\ 4U4SjjjrSrU=r $)HiDreamImageLoraLoaderMixini^za Load LoRA layers into [`HiDreamImageTransformer2DModel`]. Specific to [`HiDreamImagePipeline`]. r.rWc URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnn[SU55nU(a [ U5nU (aUU4nU$UnU$s snnf)rkrNrFrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrf>HiDreamImageLoraLoaderMixin.lora_state_dict..rrirrc3,# UH nSU;v M g7f)diffusion_modelNrbrs rQrfrs%Qj&71&.rhrirjr.r/NrOr2s rQr-HiDreamImageLoraLoaderMixin.load_lora_weightsrQrSc U(a[SS5(a [S5e[RSURS35 UR USUUUUUS9 g)ag This will load the LoRA layers specified in `state_dict` into `transformer`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. transformer (`HiDreamImageTransformer2DModel`): The Transformer model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r+r,r]rrNr5r6r7s rQr06HiDreamImageLoraLoaderMixin.load_lora_into_transformerrTrSrr;rrrrr=c 0n0n U(d [S5eURURX R55 Ub$U R[ XpR55 UR UUUUUUU S9 grVrWrXs rQr-HiDreamImageLoraLoaderMixin.save_lora_weights:rZrSrrrorrc 0>[TU]"SUUUUS.UD6 grrrs rQr%HiDreamImageLoraLoaderMixin.fuse_loratrrSc *>[TU]"SSU0UD6 gr^rrs rQr'HiDreamImageLoraLoaderMixin.unfuse_lorar`rSrbrrrarbrs@rQrr^rcrSrc^\rSrSrSrS/r\r\\ S\ \ \ \ \ R444Sj55rSS\ \ \ \ \ R44S\\ S \4S jjr\SS \4S jj5r\SS \ \ \R*4S \ \ \ \ R,R.\ R44S\S\ S\S\S\\4Sjj5rS/SSS4S\\ S\S\S\\\ 4U4SjjjrS/4S\\ 4U4SjjjrSrU=r $)QwenImageLoraLoaderMixiniz[ Load LoRA layers into [`QwenImageTransformer2DModel`]. Specific to [`QwenImagePipeline`]. r.rWc URSS5nURSS5nURSS5nURSS5nURSS5nURSS5nURS S5n URS S5n URS S5n URS S5n Sn U cS n S n SSS.n[UU U UUUUUUU UU S9 unn[SU55nU(aESn[R U5 UR 5VVs0sHunnSU;dMUU_M nnn[SU55n[SU55nU(dU(a [ U5nU (aUU4nU$UnU$s snnf)r#rNrFrrrrrrrr^Trrrrc3,# UH nSU;v M g7frrbrs rQrf;QwenImageLoraLoaderMixin.lora_state_dict..rrirrc3B# UHoRS5v M g7f)z.alphaN)rrs rQrfr3sHZzz(33ZrRc3B# UHoRS5v M g7frrrs rQrfr3sK 1LL66 rR)rprrrrrr%)rrWrrrrrrrrrrr^rrrrmrrrrhas_alphas_in_sd has_lora_unetrs rQru(QwenImageLoraLoaderMixin.lora_state_dictspJJ{D1 $4e<**Y-!::&8$? 7D)::j$/JJ{D1 jj5  **%6=%zz*@%H  ""OL#7iP 02W#+-)!%  H!$#Jz#J J {H NN8 $+5+;+;+=W+=41aUVAV$!Q$+=JWHZHHK KK }FzRJ(.Srhrirjr.r/NrOr2s rQr*QwenImageLoraLoaderMixin.load_lora_weights&rQrSc U(a[SS5(a [S5e[RSURS35 UR USUUUUUS9 g)ad This will load the LoRA layers specified in `state_dict` into `transformer`. Parameters: state_dict (`dict`): A standard state dict containing the lora layer parameters. The keys can either be indexed directly into the unet or prefixed with an additional `unet` which can be used to distinguish between text encoder lora layers. transformer (`QwenImageTransformer2DModel`): The Transformer model to load the LoRA layers into. adapter_name (`str`, *optional*): Adapter name to be used for referencing the loaded adapter model. If not specified, it will use `default_{i}` where i is the total number of adapters being loaded. low_cpu_mem_usage (`bool`, *optional*): Speed up model loading by only loading the pretrained LoRA weights and not initializing the random weights. hotswap (`bool`, *optional*): See [`~loaders.StableDiffusionLoraLoaderMixin.load_lora_weights`]. metadata (`dict`): Optional LoRA adapter metadata. When supplied, the `LoraConfig` arguments of `peft` won't be derived from the state dict. r+r,r]rrNr5r6r7s rQr03QwenImageLoraLoaderMixin.load_lora_into_transformerarTrSrr;rrrrr=c 0n0n U(d [S5eURURX R55 Ub$U R[ XpR55 UR UUUUUUU S9 grVrWrXs rQr*QwenImageLoraLoaderMixin.save_lora_weightsrZrSrrrorrc 0>[TU]"SUUUUS.UD6 grrrs rQr"QwenImageLoraLoaderMixin.fuse_lorarrSc *>[TU]"SSU0UD6 gr^rrs rQr$QwenImageLoraLoaderMixin.unfuse_lorar`rSrbrrrarbrs@rQr0r0s,_'c/4S$sELL?P:Q5Q/RccR'+ 9 /4S$sELL?P:Q5Q/R9 sm9  9 v / / / b TX $"&#'<@5 c2;;./5 "&c5%,,1N+O&O!P5  5  5  5 !5 ,4D>5 5 t"/!-1 - I- -  -  S * - - `4A/=d3i==rSr0c(^\rSrSrU4SjrSrU=r$)LoraLoaderMixinicD>Sn[SSU5 [TU]"U0UD6 g)NzLoraLoaderMixin is deprecated and this will be removed in a future version. Please use `StableDiffusionLoraLoaderMixin`, instead.rFz1.0.0)r r__init__)r~argsrdeprecation_messager?s rQrHLoraLoaderMixin.__init__s,b#W.AB $)&)rSrb)r@rrrrHrrrs@rQrFrFs **rSrF)FrtypingrrrrrrEhuggingface_hub.utilsrutilsr r r r rrrrrrr lora_baserrrrrrlora_conversion_utilsrrrrr r!r"r#r$r%r&r'r(rq get_loggerr@rrrrCrrRrUrr!rErdrr'r9rLrerwrrrr rr0rFrbrSrQrRs 88 6    "#(D'"" D( + + % ' ' #C 2 2*.'   H %"   &2M%B".ba=]a=Ht=}t=nP=P=fS=mS=l GT-GTXl :l ^P=}P=f S=MS=l U=mU=p S=-S=l U=-U=p V=]V=r \=\=~ _= _=D S=mS=l U=-U=p W=}W=t *4*rS