bi7\ddlZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z m Z ddlmZddlmZddlmZmZmZmZmZmZmZmZmZddlZddlZddlZddlmZm Z m!Z!ddl"m#Z#dd lm$Z$m%Z%dd l&m'Z'd d l(m)Z)d d l*m+Z+m,Z,d dl-m.Z.d dl/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@d dlAmBZBmCZCmDZDd dlEmFZFddlGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOGddZPe@jeRZSejdZUe%jje%jje%jje%jje%jje%jje%jje%jje%jje%jje%jje%jje%jje%jjdZee?ddrdZfndZfe;rddlgZgddlgmhZhddlimjZjmkZkdejJjdejfd ZndejJjdejfd!Zpe d"ZqGd#d$ejJjeBZrGd%d&erZsy)'N) OrderedDict) ExitStackcontextmanager)wraps)Path) AnyCallableContextManagerDictListOptionalTupleTypeUnion) DDUFEntry create_repo"split_torch_state_dict_into_shards)validate_hf_hub_args)Tensornn)Self) __version__)DiffusersAutoQuantizerDiffusersQuantizer)QuantizationMethod) CONFIG_NAMEFLAX_WEIGHTS_NAMEHF_ENABLE_PARALLEL_LOADINGSAFE_WEIGHTS_INDEX_NAMESAFETENSORS_WEIGHTS_NAMEWEIGHTS_INDEX_NAME WEIGHTS_NAME _add_variant_get_checkpoint_shard_files_get_model_file deprecateis_accelerate_availableis_bitsandbytes_availableis_bitsandbytes_versionis_peft_availableis_torch_versionlogging)PushToHubMixinload_or_create_model_cardpopulate_model_card)empty_device_cache)_caching_allocator_warmup_determine_device_map_expand_device_map_fetch_index_file_fetch_index_file_legacy_load_shard_file!_load_shard_files_with_threadpoolload_state_dictc.eZdZdZdeefdZdZdZy)ContextManagersz Wrapper for `contextlib.ExitStack` which enters a collection of context managers. Adaptation of `ContextManagers` in the `fastcore` library. context_managersc0||_t|_yN)r=rstack)selfr=s Z/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/diffusers/models/modeling_utils.py__init__zContextManagers.__init__Vs 0[ c\|jD]}|jj|yr?)r=r@ enter_context)rAcontext_managers rB __enter__zContextManagers.__enter__Zs)#44 6O JJ $ $_ 5 6rDc<|jj|i|yr?)r@__exit__)rAargskwargss rBrJzContextManagers.__exit__^s T,V,rDN) __name__ __module__ __qualname____doc__r r rCrHrJrDrBr<r<Ps" !n)=!6-rDr<z(.*?)-\d{5}-of-\d{5})uniform_normal_ trunc_normal_ constant_xavier_uniform_xavier_normal_kaiming_uniform_kaiming_normal_uniformnormalxavier_uniform xavier_normalkaiming_uniformkaiming_normal>=1.9.0TF)dispatch_model)load_offloaded_weightssave_offload_index parameterreturncddlm} ||S#t$rYnwxYw tj|j |j }t|jS#t$rgdtjjdtttt ffd}|j#|}t|}|djcYSwxYw)Nr)_get_group_onload_devicemodulerfc|jjDcgc]\}}tj|s||f!}}}|Scc}}wr?__dict__itemstorch is_tensorrikvtupless rBfind_tensor_attributesz4get_parameter_device..find_tensor_attributessA)/)>)>)@WAEOOTUDVq!fWFWMX AAget_members_fnr2)hooks.group_offloadingrh ValueError itertoolschain parametersbuffersnextdevice StopIterationrnrModuler rstrr_named_members)rerhparameters_and_buffersrtgen first_tuples rBget_parameter_devicersA ' 22    %"+1E1E1GIZIZI\!]*+222  % 588?? tE#v+DV?W &&6L&M3i 1~$$$ %s AA''A-CCcZ t|tjrR|jD]?\ }t |ds|j }|j d}|3|jcSd}|jD]f\ }|j}t |dr+|jrt fd|jDrI|jsZ|jcS|jD],}|j}|js |jcS||Sdtjdttt t"ffd}|j%| }d} |D](} | } | d js| d jcS| | d jSy) zz Returns the first found floating dtype in parameters if there is one, otherwise returns the last dtype it found. _diffusers_hooklayerwise_castingN_keep_in_fp32_modulesc3&K|]}|v ywr?rQ).0mnames rB z&get_parameter_dtype..sG!AIGsrirfc|jjDcgc]\}}tj|s||f!}}}|Scc}}wr?rkrps rBrtz3get_parameter_dtype..find_tensor_attributessA%+__%:%:%<STQPQ@R1a&SS Trurvr2) isinstancerr named_moduleshasattrrget_hook compute_dtypenamed_parametersdtyperanyis_floating_pointr}r rrrr) re submoduleregistryhook last_dtypeparambufferrtr last_tupletuplers @rBget_parameter_dtypers )RYY'(668 *OD)9&78 00H$$%89D)))  *J 113  e[[ I6 7//Gy'F'FGG   " " $;;  ##% \\  # # %<<  ryyT%V :L5M  " "2H " ICJ" 8 % % '8>> !" !}"""rDc#Kd}tjD]*\}}ttjj ||, dtjD]*\}}ttjj ||,y#tjD]*\}}ttjj ||,wxYww)z Context manager to globally disable weight initialization to speed up loading large models. To do that, all the torch.nn.init function are all replaced with skip. cyr?rQ)rKrLs rB _skip_initz#no_init_weights.._skip_inits rDN)TORCH_INIT_FUNCTIONSrmsetattrrnrinit)rr init_funcs rBno_init_weightsrs 05571i tZ014  499; 4OD) EHHMM4 3 4399; 4OD) EHHMM4 3 4s ACB ACACCc!eZdZdZeZgdZdZdZdZ dZ dZ dZ gZ fdZdedeffd Zedefd ZdZd eeddfd Zd[d ZdeddfdZd[dZd[dZ dZdedeeddfdZdZdeefdZdZ dZdedeeddfdZdZdeeddfdZ d[dZ!e"jFddddfde"jHdee"jHdee%edfdee%e&e"jNjPdfd eddf d!Z)e"jTd"d#ddddddfd$e"jTd%e"jTd&ed'ee+d ed(ed)ed*eeddfd+Z,d,eddfd-Z-d[d.Z. d\d/e/ee0jbfd0ed1eed2ed3eed4e/e+efd5efd6Z2d7Z3e4e5d8ee/ee0jbfde6fd9Z7e8e"jNjPjrfd:Z9e8e"jNjPjtfd;Z:fd<Z;fd=ZZ=e4 d]d?e>d@e?ed8e/ee0jbfdAe?edBedCedDee@dEedFee/ee"jHfdGee?edHe/ee+e"jTeAee/e+ee"jTfffdIeedJee/ee0jbfdKeeAeeBfdLeefdMZCe4dNZDdHefdOZEe4dFe"jHde"jHfdPZFede"jTfdQZ*ede"jHfdRZ$d^dSedTede+fdUZGd_dVZHde"jjjfdWed eddfdXZKd?e>ddfdYZLxZMS)` ModelMixina$ Base class for all models. [`ModelMixin`] takes care of storing the model configuration and provides methods for loading, downloading and saving models. - **config_name** ([`str`]) -- Filename to save a model to when calling [`~models.ModelMixin.save_pretrained`]. )_diffusers_version _class_name _name_or_pathFNTc0t|d|_yr?)superrC_gradient_checkpointing_func)rA __class__s rBrCzModelMixin.__init__s ,0)rDrrfc Fd|jvxrt|jd|}||jv}|rY|sWd|dt|jd|dt|jd|d }t dd |d d |j |St ||S) a~The only reason we overwrite `getattr` here is to gracefully deprecate accessing config attributes directly. See https://github.com/huggingface/diffusers/pull/3129 We need to overwrite __getattr__ here in addition so that we don't trigger `torch.nn.Module`'s __getattr__': https://pytorch.org/docs/stable/_modules/torch/nn/modules/module.html#Module _internal_dictzAccessing config attribute `z` directly via 'z1' object attribute is deprecated. Please access 'z' over 'z,'s config object instead, e.g. 'unet.config.z'.zdirect config name accessz1.0.0F) standard_warn stacklevel)rlrtyperMr'rr __getattr__)rAr is_in_config is_attributedeprecation_messagers rBrzModelMixin.__getattr__s(4==8kWT]]ScEdfj=k t}},  $@FVW[\`WaWjWjVkl]^b]ccklpqulvllk@@lmqlrrt#u  17.s'mYZ7167TA._gradient_checkpointing_func,sO:J4QY:Z6`b {{--88OO"rDT)enabler) _supports_gradient_checkpointingryrrM_set_gradient_checkpointing)rArrs rBenable_gradient_checkpointingz(ModelMixin.enable_gradient_checkpointings`44>>**+,XY  ' . +G ' ((Rm(nrDcB|jr|jdyy)z Deactivates gradient checkpointing for the current model (may be referred to as *activation checkpointing* or *checkpoint activations* in other frameworks). F)rN)rrrs rBdisable_gradient_checkpointingz)ModelMixin.disable_gradient_checkpointing8s#  0 0  , ,E , : 1rDvalidcdtjjffd |jD]/}t |tjjs(|1y)z= Set the switch for the npu flash attention. riczt|dr|j|jD] }| y)Nset_use_npu_flash_attention)rrchildren)richild$fn_recursive_set_npu_flash_attentionrs rBrzTModelMixin.set_use_npu_flash_attention..fn_recursive_set_npu_flash_attentionEs:v<=2259* <4U; .fn_recursive_set_flash_attentiondsEv<=2223JNe^de* 807 8rDr)rArrrLrirs ``` @rBrz&ModelMixin.set_use_xla_flash_attention^sM  8UXX__ 8 8mmo 9F&%((//208 9rDc ,|jd|fi|y)zJ Enable the flash attention pallals kernel for torch_xla. TNr)rArrLs rBenable_xla_flash_attentionz%ModelMixin.enable_xla_flash_attentionos )((~HHrDc&|jdy)zK Disable the flash attention pallals kernel for torch_xla. FNrrs rBdisable_xla_flash_attentionz&ModelMixin.disable_xla_flash_attentionus ((/rD attention_opcdtjjffd |jD]/}t |tjjs(|1y)Nric|t|dr|j|jD] }| y)N+set_use_memory_efficient_attention_xformers)rrr)rirrfn_recursive_set_mem_effrs rBrzXModelMixin.set_use_memory_efficient_attention_xformers..fn_recursive_set_mem_effs<vLMBB5,W* 0(/ 0rDr)rArrrirs `` @rBrz6ModelMixin.set_use_memory_efficient_attention_xformers{sH  0UXX__ 0mmo 1F&%((//2(0 1rDc(|jd|y)uE Enable memory efficient attention from [xFormers](https://facebookresearch.github.io/xformers/). When this option is enabled, you should observe lower GPU memory usage and a potential speed up during inference. Speed up during training is not guaranteed. ⚠️ When memory efficient attention and sliced attention are both enabled, memory efficient attention takes precedent. Parameters: attention_op (`Callable`, *optional*): Override the default `None` operator for use as `op` argument to the [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) function of xFormers. Examples: ```py >>> import torch >>> from diffusers import UNet2DConditionModel >>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp >>> model = UNet2DConditionModel.from_pretrained( ... "stabilityai/stable-diffusion-2-1", subfolder="unet", torch_dtype=torch.float16 ... ) >>> model = model.to("cuda") >>> model.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp) ``` TNr)rArs rB*enable_xformers_memory_efficient_attentionz5ModelMixin.enable_xformers_memory_efficient_attentionsD 88|LrDc&|jdy)zs Disable memory efficient attention from [xFormers](https://facebookresearch.github.io/xformers/). FNrrs rB+disable_xformers_memory_efficient_attentionz6ModelMixin.disable_xformers_memory_efficient_attentions 88?rD storage_dtyperskip_modules_pattern.skip_modules_classes non_blockingcddlm}d}| ddlm}|}d}|j|t |jz }|j |t |j z }t t|}tr6|s4ddl m } dd l m } dd l m} | | | fD]} |t | jz }|!t j#d |j$}|||||||y) a Activates layerwise casting for the current model. Layerwise casting is a technique that casts the model weights to a lower precision dtype for storage but upcasts them on-the-fly to a higher precision dtype for computation. This process can significantly reduce the memory footprint from model weights, but may lead to some quality degradation in the outputs. Most degradations are negligible, mostly stemming from weight casting in normalization and modulation layers. By default, most models in diffusers set the `_skip_layerwise_casting_patterns` attribute to ignore patch embedding, positional embedding and normalization layers. This is because these layers are most likely precision-critical for quality. If you wish to change this behavior, you can set the `_skip_layerwise_casting_patterns` attribute to `None`, or call [`~hooks.layerwise_casting.apply_layerwise_casting`] with custom arguments. Example: Using [`~models.ModelMixin.enable_layerwise_casting`]: ```python >>> from diffusers import CogVideoXTransformer3DModel >>> transformer = CogVideoXTransformer3DModel.from_pretrained( ... "THUDM/CogVideoX-5b", subfolder="transformer", torch_dtype=torch.bfloat16 ... ) >>> # Enable layerwise casting via the model, which ignores certain modules by default >>> transformer.enable_layerwise_casting(storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16) ``` Args: storage_dtype (`torch.dtype`): The dtype to which the model should be cast for storage. compute_dtype (`torch.dtype`): The dtype to which the model weights should be cast during the forward pass. skip_modules_pattern (`Tuple[str, ...]`, *optional*): A list of patterns to match the names of the modules to skip during the layerwise casting process. If set to `None`, default skip patterns are used to ignore certain internal layers of modules and PEFT layers. skip_modules_classes (`Tuple[Type[torch.nn.Module], ...]`, *optional*): A list of module classes to skip during the layerwise casting process. non_blocking (`bool`, *optional*, defaults to `False`): If `True`, the weight casting operations are non-blocking. r)apply_layerwise_castingTN)DEFAULT_SKIP_MODULES_PATTERNFr) LoHaLayer) LoKrLayer) LoraLayerzW`compute_dtype` not provided when enabling layerwise casting. Using dtype of the model.)hooksrhooks.layerwise_castingrrr _skip_layerwise_casting_patternssetr+peft.tuners.loha.layerrpeft.tuners.lokr.layerrpeft.tuners.lora.layerradapter_layer_namesloggerinfor) rArrrrrruser_provided_patternsrrrrlayers rBenable_layerwise_castingz#ModelMixin.enable_layerwise_castingsd 4!%  ' N#? %* "  % % 1 E$*D*D$E E  0 0 < E$*O*O$P P $S)=%>?  '= 9 8 8#Y : I$e.G.G(HH$ I  KKq r JJM -0DFZ\h rDcpu block_level onload_deviceoffload_device offload_typenum_blocks_per_group use_stream record_streamoffload_to_disk_pathc ddlm} t|dd&t|ddr|rd} tj | |j s"t |jjd| |||||||||| y) a Activates group offloading for the current model. See [`~hooks.group_offloading.apply_group_offloading`] for more information. Example: ```python >>> from diffusers import CogVideoXTransformer3DModel >>> transformer = CogVideoXTransformer3DModel.from_pretrained( ... "THUDM/CogVideoX-5b", subfolder="transformer", torch_dtype=torch.bfloat16 ... ) >>> transformer.enable_group_offload( ... onload_device=torch.device("cuda"), ... offload_device=torch.device("cpu"), ... offload_type="leaf_level", ... use_stream=True, ... ) ``` r)apply_group_offloading enable_tilingN use_tilingFa/Applying group offloading on autoencoders, with CUDA streams, may not work as expected if the first forward pass is executed with tiling enabled. Please make sure to either: 1. Run a forward pass with small input shapes. 2. Or, run a forward pass with tiling disabled (can still use small dummy inputs).z does not support group offloading. Please make sure to set the boolean attribute `_supports_group_offloading` to `True` in the class definition. If you believe this is a mistake, please open an issue at https://github.com/huggingface/diffusers/issues.) rirrrrrrrlow_cpu_mem_usager) rrgetattrrwarning_supports_group_offloadingryrrM) rArrrrrrrrrrmsgs rBenable_group_offloadzModelMixin.enable_group_offload sD 3 4$ / ;l\a@bgqe  NN3 ..>>**+,TU  ')%!5%!'/!5 rDbackendcddlm}ddlm}m}ddlm}m}tjd|j}|jjDchc]}|j}}||vr!td|ddj|z||}|||||f} |j!D]1} t#| | s| j$} | t'| d s+|| _3y cc}w) a Set the attention backend for the model. Args: backend (`str`): The name of the backend to set. Must be one of the available backends defined in `AttentionBackendName`. Available backends can be found in `diffusers.attention_dispatch.AttentionBackendName`. Defaults to torch native scaled dot product attention as backend. r2AttentionModuleMixin)AttentionBackendName%_check_attention_backend_requirements AttentionMochiAttentionTAttention backends are an experimental feature and the API may be subject to change.z `backend=z ` must be one of the following: , N_attention_backend) attentionr#attention_dispatchr$r%attention_processorr'r(rrlower __members__valuesvalueryjoinrr processorrr+) rAr r#r$r%r'r(xavailable_backendsattention_classesrir4s rBset_attention_backendz ModelMixin.set_attention_backendJs 4c Cmn--//C/O/O/V/V/XY!aggYY , ,z *JKdiiXjNkkl l&w/-g6&8LMlln 3Ff&78((I  ;O(P+2I (  3ZsC,cddlm}ddlm}m}t j d|||f}|jD]1}t||s|j}| t|ds+d|_ 3y)z Resets the attention backend for the model. Following calls to `forward` will use the environment default or the torch native scaled dot product attention. r2r"r&r)Nr+) r,r#r.r'r(rrrrr4rr+)rAr#r'r(r7rir4s rBreset_attention_backendz"ModelMixin.reset_attention_backendmsn 4Bmn&8LMlln 0Ff&78((I  ;O(P+/I (  0rDsave_directoryis_main_process save_functionsafe_serializationvariantmax_shard_size push_to_hubc tjj|rtj d|dyt |dd} | I| duxrt | txr | j} | s#td| jjd|rtnt} t| |} | jddjd d } tj |d |r|j#d d} |j#dd}|j#dd}|j#dd}|j#d|j%tjj&d}t)|d ||j*}|}|r|j-||j/}t1||| }|r tj2|D]}||j4j7vr tjj9||}tjj|s`| jddjd d}|jdd}|jddjd d}|j;|st<j?|tj@||j4jCD]\}}|Dcic]}|||jE}}tjj9||}|r%tFjHjK||ddintIjL|||jNr|jP|jRd}|rtTntV}tjj9|t||}tY|dd5}t[j\|dd d!z} |j_| dddtjad"|d#tc|j4d$|d%n8tjj9|| }!tjad&|!|rXte'}"tg|"}"|"jMti|d(jk|jm||| )yycc}w#1swYxYw)*a Save a model and its configuration file to a directory so that it can be reloaded using the [`~models.ModelMixin.from_pretrained`] class method. Arguments: save_directory (`str` or `os.PathLike`): Directory to save a model and its configuration file to. Will be created if it doesn't exist. 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`. variant (`str`, *optional*): If specified, weights are saved in the format `pytorch_model..bin`. max_shard_size (`int` or `str`, defaults to `"10GB"`): The maximum size for a checkpoint before being sharded. Checkpoints shard will then be each of size lower than this size. If expressed as a string, needs to be digits followed by a unit (like `"5GB"`). If expressed as an integer, the unit is bytes. Note that this limit will be decreased after a certain period of time (starting from Oct 2024) to allow users to upgrade to the latest version of `diffusers`. This is to establish a common default size for this argument across different libraries in the Hugging Face ecosystem (`transformers`, and `accelerate`, for example). push_to_hub (`bool`, *optional*, defaults to `False`): Whether or not to push your model to the Hugging Face Hub after saving it. You can specify the repository you want to push to with `repo_id` (will default to the name of `save_directory` in your namespace). kwargs (`Dict[str, Any]`, *optional*): Additional keyword arguments passed along to the [`~utils.PushToHubMixin.push_to_hub`] method. zProvided path (z#) should be a directory, not a fileN hf_quantizerzThe model is quantized with z and is not serializable - check out the warnings from the logger on the traceback to understand the reason why the quantized model is not serializable.z.binz {suffix}.binz .safetensorsz{suffix}.safetensorsTexist_okcommit_messageprivate create_prFtokenrepo_id)rErGrI)r@filename_patternz{suffix}formatpt)metadata)rP weight_mapwzutf-8)encodingr)indent sort_keys z:The model is bigger than the maximum size per checkpoint (z) and is going to be split in z^ checkpoint shards. You can find where each parameters has been saved in the index located at .zModel weights saved in )rIz README.md)rIrFrH)7ospathisfilererrorrrris_serializableryquantization_config quant_methodr!r#r$replacemakedirspopsplitseprrJ save_config state_dictrlistdirfilename_to_tensorskeysr3 startswith _REGEX_SHARD fullmatchremoverm contiguous safetensorsrn save_filesave is_shardedrPtensor_to_filenamer r"openjsondumpswriter lenr/r0ras_posix_upload_folder)#rAr;r<r=r>r?r@rArLrCquantization_serializable weights_nameweights_name_patternrFrGrHrIrJ model_to_saverestate_dict_splitfilename full_filenameweights_without_extfilename_without_exttensorstensorshardfilepathindexsave_index_filefcontentpath_to_weights model_cards# rBsave_pretrainedzModelMixin.save_pretrainedsX 77>>. ) LL?>*::]^ _ t^T:  #D(1|-?@1 00 & - 2<3S3S3`3`2abyy 4F/< #L': +33FNKSS 2  NT2 #ZZ(8$?NjjD1G ;6IJJw-EjjN,@,@,Mb,QRG!'D'QVW__G    % %n 5#--/ > ~H\  JJ~6 -/CCHHJJ " ^X F ww~~m4&:&B&B62&N&V&VWegi&j#&9&A&A*b&Q#'/'7'7'C'K'KN\^'_$''(;<$../CDPIIm, - "2!E!E!K!K!M , HgKRSVZ/::<<SESww||NH=H!!!++E8xQUFV+W 5(+ ,  & &,55.AAE:L5QcO ggll><Y`;abOosW= !**U1EL  ! KKL^L\] 0 D DEFG$$3#4A7  !ggll><HO KK1/1BC D 27%HJ,Z8J OOD=FFH I   -#   ;T" ! !s(S -SScXt|dd}| td|j|S)z Potentially dequantize the model in case it has been quantized by a quantization method that support dequantization. rCNz?You need to first quantize your model in order to dequantize it)rry dequantize)rArCs rBrzModelMixin.dequantizes5 t^T:  ^_ _&&t,,rDpretrained_model_name_or_pathc |jdd}|jdd}|jdd}|jdd}|jdd}|jdd}|jd d} |jd d} |jd d} |jd d} |jd d} |jdd}|jdd}|jdd}|jdd}|jdt}|jdd}|jdd}|jdd}|jdd}|jdd}t}|r |s td| Ct | t j s)t j} tjd| dd}|d}d}|r!tsd}tjd|ts td|tdds td |durtdds td!|dur|td"|d#t |t jrd$|i}nQt |tr|d%vr d$t j|i}n$t |t r|d(kr td)d$|i}||d}n |s td*|r|tdd+s td,t"d-d.d/}i}|}|j$|f|dd||| | | | ||d0 |\}}}t'j(|}d|vxr|ddu}|s|?|rt+j,|d||d<n||d<t+j.|d|1} nd} | | j1| ||2| j3| } | j5|}| j6j8j:|d3<|d}tj=d4n |s td5|j>duxr| duxs tA| d6d}!|!rF|j>}"t |"tBs|"g}"|d}tj=d7n|s td8g}"d}#d}$d}%d}&tDjFjI|}'|'|| xsd$|||||| | | |||d9}(tKdNi|(}&|,|&tDjFjM|&s tOdNi|(}&|&|s|&jQrd}#|#r |r td:|r=tS|tT|||| | | | ||; }$|j.|fi|})d \}$}%n(|r& tS|t]t^||||| | | | |||? }$|$'|#s%tS|t]td||||| | | | |||? }$t |$tBs|$g}$d},| Y| tAt dCdk(sEt | t j st| dDtg| d'|ji| },tkg}-|r#|-jmtojpts|-5|j.|fi|})ddd|,t jt|,d}.|#s"tw|$d(||E}.)jy|.|#r|%dF}/ntC|.j{}/| | j})||"Gt)||| |"| }| | j1|H|j|)|.|$||/|||||| | |"||I\})}0}1}2}3}4|0|1|2|4dJ}5||||3dK}6t|)fi|6| | j|)| |)_C| )| tAt dCdk(r| |!s|)j| })| |)j|| Ln|)j|M|)j|r|)|5fS|)S#t$rtd&|d'wxYw#t`$r>}+tjcd@|dA|+|stjdBYd}+~+d}+~+wwxYw#1swYxYw)OuL! Instantiate a pretrained PyTorch model from a pretrained model configuration. The model is set in evaluation mode - `model.eval()` - by default, and dropout modules are deactivated. To train the model, set it back in training mode with `model.train()`. Parameters: pretrained_model_name_or_path (`str` or `os.PathLike`, *optional*): 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`]. 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. torch_dtype (`torch.dtype`, *optional*): Override the default `torch.dtype` and load the model with another dtype. 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. output_loading_info (`bool`, *optional*, defaults to `False`): Whether or not to also return a dictionary containing missing keys, unexpected keys and error messages. 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. from_flax (`bool`, *optional*, defaults to `False`): Load the model weights from a Flax checkpoint save file. subfolder (`str`, *optional*, defaults to `""`): The subfolder location of a model file within a larger model repository on the Hub or locally. mirror (`str`, *optional*): Mirror source to resolve accessibility issues if you're downloading a model in China. We do not guarantee the timeliness or safety of the source, and you should refer to the mirror site for more information. device_map (`Union[int, str, torch.device]` or `Dict[str, Union[int, str, torch.device]]`, *optional*): A map that specifies where each submodule should go. It doesn't need to be defined for each parameter/buffer name; once a given module name is inside, every submodule of it will be sent to the same device. Defaults to `None`, meaning that the model will be loaded on CPU. Examples: ```py >>> from diffusers import AutoModel >>> import torch >>> # This works. >>> model = AutoModel.from_pretrained( ... "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", device_map="cuda" ... ) >>> # This also works (integer accelerator device ID). >>> model = AutoModel.from_pretrained( ... "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", device_map=0 ... ) >>> # Specifying a supported offloading strategy like "auto" also works. >>> model = AutoModel.from_pretrained( ... "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", device_map="auto" ... ) >>> # Specifying a dictionary as `device_map` also works. >>> model = AutoModel.from_pretrained( ... "stabilityai/stable-diffusion-xl-base-1.0", ... subfolder="unet", ... device_map={"": torch.device("cuda")}, ... ) ``` Set `device_map="auto"` to have 🤗 Accelerate automatically compute the most optimized `device_map`. For more information about each option see [designing a device map](https://huggingface.co/docs/accelerate/en/concept_guides/big_model_inference#the-devicemap). You can also refer to the [Diffusers-specific documentation](https://huggingface.co/docs/diffusers/main/en/training/distributed_inference#model-sharding) for more concrete examples. max_memory (`Dict`, *optional*): A dictionary device identifier for the maximum memory. Will default to the maximum memory available for each GPU and the available CPU RAM if unset. offload_folder (`str` or `os.PathLike`, *optional*): The path to offload weights if `device_map` contains the value `"disk"`. offload_state_dict (`bool`, *optional*): If `True`, temporarily offloads the CPU state dict to the hard drive to avoid running out of CPU RAM if the weight of the CPU state dict + the biggest shard of the checkpoint does not fit. Defaults to `True` when there is some disk offload. low_cpu_mem_usage (`bool`, *optional*, defaults to `True` if torch version >= 1.9.0 else `False`): Speed up model loading only loading the pretrained weights and not initializing the weights. This also tries to not use more than 1x model size in CPU memory (including peak memory) while loading the model. Only supported for PyTorch >= 1.9.0. If you are using an older version of PyTorch, setting this argument to `True` will raise an error. variant (`str`, *optional*): Load weights from a specified `variant` filename such as `"fp16"` or `"ema"`. This is ignored when loading `from_flax`. use_safetensors (`bool`, *optional*, defaults to `None`): If set to `None`, the `safetensors` weights are downloaded if they're available **and** if the `safetensors` library is installed. If set to `True`, the model is forcibly loaded from `safetensors` weights. If set to `False`, `safetensors` weights are not loaded. disable_mmap ('bool', *optional*, defaults to 'False'): Whether to disable mmap when loading a Safetensors model. This option can perform better when the model is on a network mount or hard drive, which may not handle the seeky-ness of mmap very well. To use private or [gated models](https://huggingface.co/docs/hub/models-gated#gated-models), log-in with `hf auth login`. You can also activate the special ["offline-mode"](https://huggingface.co/diffusers/installation.html#offline-mode) to use this method in a firewalled environment. Example: ```py from diffusers import UNet2DConditionModel unet = UNet2DConditionModel.from_pretrained("runwayml/stable-diffusion-v1-5", subfolder="unet") ``` If you get the error message below, you need to finetune the weights for your downstream task: ```bash Some weights of UNet2DConditionModel were not initialized from the model checkpoint at runwayml/stable-diffusion-v1-5 and are newly initialized because the shapes did not match: - conv_in.weight: found shape torch.Size([320, 4, 3, 3]) in the checkpoint and torch.Size([320, 9, 3, 3]) in the model instantiated You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference. ``` cache_dirNignore_mismatched_sizesFforce_download from_flaxproxiesoutput_loading_infolocal_files_onlyrIrevision torch_dtype subfolder device_map max_memoryoffload_folderoffload_state_dictrr?use_safetensorsr] dduf_entries disable_mmapzEParallel loading is not supported when not using `low_cpu_mem_usage`.zPassed `torch_dtype` z7 is not a `torch.dtype`. Defaulting to `torch.float32`.Ta,Cannot initialize model with low cpu memory usage because `accelerate` was not found in the environment. Defaulting to `low_cpu_mem_usage=False`. It is strongly recommended to install `accelerate` for faster and less memory-intense model loading. You can do so with: ``` pip install accelerate ``` .zLoading and dispatching requires `accelerate`. Please make sure to install accelerate or set `device_map=None`. You can install accelerate with `pip install accelerate`.r`raztLoading and dispatching requires torch >= 1.9.0. Please either update your PyTorch version or set `device_map=None`.z~Low memory initialization requires torch >= 1.9.0. Please either update your PyTorch version or set `low_cpu_mem_usage=False`.zEYou cannot set `low_cpu_mem_usage` to `False` while using device_map=zO for loading and dispatching. Please make sure to set `low_cpu_mem_usage=True`.rM)autobalancedbalanced_low_0 sequentialzWhen passing device_map as a string, the value needs to be a device name (e.g. cpu, cuda:0) or 'auto', 'balanced', 'balanced_low_0', 'sequential' but found rWrznYou can't pass device_map as a negative int. If you want to put the model on the cpu, pass device_map = 'cpu' z>Passing along a `device_map` requires `low_cpu_mem_usage=True`z1.10z=`low_cpu_mem_usage` and `device_map` require PyTorch >= 1.10.modelpytorch diffusers file_type framework) rreturn_unused_kwargsreturn_commit_hashrrrrIrr user_agentr) pre_quantized)rrrquantz>Set `low_cpu_mem_usage` to True as `hf_quantizer` is not None.zD`low_cpu_mem_usage` cannot be False or None when using quantization.use_keep_in_fp32_moduleszGSet `low_cpu_mem_usage` to True as `_keep_in_fp32_modules` is not None.zH`low_cpu_mem_usage` cannot be False when `keep_in_fp32_modules` is True.)is_localrrrrr?rrrrIrr commit_hashrzFLoading of sharded checkpoints is not supported when `from_flax=True`.) r{rrrrrIrrrrr2)%load_flax_checkpoint_in_pytorch_model)rrrrIrrrr) r{rrrrrIrrrrrz(An error occurred while trying to fetch z: zXDefaulting to unsafe serialization. Pass `allow_pickle=False` to raise an error instead. float8_e4m3fnzA needs to be of type `torch.dtype`, e.g. `torch.float16`, but is )rrall_checkpoint_keys)rrkeep_in_fp32_modules)r) rrrrrrrCrris_parallel_loading_enabled) missing_keysunexpected_keysmismatched_keys error_msgs)r offload_dir offload_index)r_pre_quantization_dtype)rrQ)Gra_LOW_CPU_MEM_USAGE_DEFAULTrNotImplementedErrorrrnrfloat32rrr(r,ryrr RuntimeErrorintr load_configcopydeepcopyrmerge_quantization_configs from_configvalidate_environmentupdate_torch_dtypeupdate_device_mapr]r^r2r rrlistrXrYisdirr6existsr7is_filer&rmodeling_pytorch_flax_utilsrr%r$r!IOErrorr[r#r_set_default_torch_dtyperappend accelerateinit_empty_weightsr<set_default_dtyper:_fix_state_dict_keys_on_loadrhpreprocess_modelr4_load_pretrained_modelrbpostprocess_modelrCtoregister_to_configeval)7clsrrLrrrrrrrrIrrrrrrrrr?rr]rrr allow_pickler unused_kwargs config_pathconfigrrrCrrrqresolved_model_filesharded_metadata index_filerindex_file_kwargsrre dtype_orig init_contextsre loaded_keysrrrrr loading_infodevice_map_kwargss7 rBfrom_pretrainedzModelMixin.from_pretrained'sL NJJ{D1 "(**-F"N$4e<JJ{E2 **Y-$jj)>F!::&8$? 7D)::j$/jj5 JJ{D1 ZZ d3 ZZ d3 $4d;#ZZ(E7=zz.RV7W zz.%8 &@# &/@%&mn n  ":k5;;+O--K NN' }4kl   ""OL %<%> %  NN.   !*A*C%`   !*:4*I%&   $-=dG-L%.   %**@WXbWcdRR  j%,, /j)J  C (Z?s-s  %,,z":;  C (A~ E!*-  ! ($(!& !abb %.>tV.L !`aa% "  4 .=S__ . !%#)-!%. . * { v&.7eFCX? -J"b.", 0 $&(  ';):;   J$6bggnnZ>X1F4EFJ  !|z7I7I7KJ )ef f "1-.#-!1!#%' # $COOF!>!@ A ] + =#COOFa9` a3aaa)cRddlm}t|ddtjk(r=t|ddr t dt ddrt d |jd ||r/tjd |jjd |St|4|i|S) Nr_is_group_offload_enabledquantization_methodis_loaded_in_8bitFzCalling `cuda()` is not supported for `8-bit` quantized models. Please use the model as it is, since the model has already been set to the correct devices.<0.43.2zCalling `cuda()` is not supported for `4-bit` quantized models with the installed version of bitsandbytes. The current device is `L`. If you intended to move the model, please install bitsandbytes >= 0.43.2. The module 'zD' is group offloaded and moving it using `.cuda()` is not supported.)rxrrrBITS_AND_BYTESryr*rrrrrMrcuda)rArKrLrrs rBrzModelMixin.cudaEsF 4. 59K9Z9Z Zt0%8 s)h7 ..2kk];GH %T * NNt~~6677{| Kw|T,V,,rDcddlm}td|Dxsd|v}d|v}|D]+}t|ts t j |d}-|s%|D] }t|t jsd}nt|ddr |r td t|d dtjk(r=t|d dr td td drtd|j d||r1|r/tjd|j j"d|St%|L|i|S#t$rYwxYw)Nrrc3PK|]}t|tj ywr?)rrnr)rargs rBrz ModelMixin.to..ds)XC*S%,,*G)XrrrT is_quantizedFzCasting a quantized model to a new `dtype` is unsupported. To set the dtype of unquantized layers, please use the `torch_dtype` argument when loading the model using `from_pretrained` or `from_single_file`rrz`.to` is not supported for `8-bit` bitsandbytes models. Please use the model as it is, since the model has already been set to the correct devices and casted to the correct `dtype`.rrzCalling `to()` is not supported for `4-bit` quantized models with the installed version of bitsandbytes. The current device is `rrzB' is group offloaded and moving it using `.to()` is not supported.)rxrrrrrnrrrrryrrr*rrrrMrr)rArKrLrdevice_arg_or_kwarg_presentdtype_present_in_argsrrs rBrz ModelMixin.to`sF&))XSW)X&X&n\dhn\n# '6 1 Cc3'  S!.2+  % c5;;/,0)  4 /$ z 4. 59K9Z9Z Zt0%8 l)h7 ..2kk];GH %T */J NNt~~6677yz Kwz4*6**E   sD88 EEcLt|ddr tdt| |S)NrFz`.half()` is not supported for quantized model. Please use the model as it is, since the model has already been cast to the correct `dtype`.)rryrhalfrArKrs rBrzModelMixin.halfs3 4 /G  7<& &rDcLt|ddr tdt| |S)NrFz`.float()` is not supported for quantized model. Please use the model as it is, since the model has already been cast to the correct `dtype`.)rryrfloatrs rBrzModelMixin.floats3 4 /G  7=$' 'rDct|dd}|s#td|jjdd}|j D]/}|jj|vs|j |i|d}1|std|dy) u Compiles *only* the frequently repeated sub-modules of a model (e.g. the Transformer layers) instead of compiling the entire model. This technique—often called **regional compilation** (see the PyTorch recipe https://docs.pytorch.org/tutorials/recipes/regional_compilation.html) can reduce end-to-end compile time substantially, while preserving the runtime speed-ups you would expect from a full `torch.compile`. The set of sub-modules to compile is discovered by the presence of **`_repeated_blocks`** attribute in the model definition. Define this attribute on your model subclass as a list/tuple of class names (strings). Every module whose class name matches will be compiled. Once discovered, each matching sub-module is compiled by calling `submodule.compile(*args, **kwargs)`. Any positional or keyword arguments you supply to `compile_repeated_blocks` are forwarded verbatim to `torch.compile`. _repeated_blocksNzM`_repeated_blocks` attribute is empty. Set `_repeated_blocks` for the class `z&` to benefit from faster compilation. FTz$Regional compilation failed because z% classes are not found in the model. )rryrrMrcompile)rArKrLrepeated_blockshas_compiled_regionsubmods rBcompile_repeated_blocksz"ModelMixin.compile_repeated_blockss"$(:DA99=9P9P8QQwy $lln +F((O;//&*# + #66GGlm #rDrerrrassign_to_params_buffersrCrrrrrrrrc$|j}t|j}tt|t|z }||j ||d}tt|t|z }|j 7|j D](}|Dcgc]}t j|||}}*g}g}| :d| jvr(| tdtj|d| d} | t| |}t||| || d| jvrind}d\}}| rtj}i}||g}t!j"|rt$nt&f||| | || ||||||||| d}|r||\}}}}||z }||z }nE|} t)|d kDrt+j,|d } | D]}!||!\}}}}||z }||z }t/|@t)|d kDr2t1||d}| r"t3|||t5j6|t)|d kDr?d j9|}"d|"vr|"dz }"t;d|j<j>d|"t)|d kDr9t@jCd|d|j>ddj9|gn-t@jEd|j<j>dt)|d kDr4t@jCd|j<j>d|d|dnUt)|d k(rGt@jEd|j<j>d|d|j<j>dt)|d kDrdd j9|D#$%cgc]\}#}$}%d!|#d"|$d#|%d$c}%}$}#}&t@jCd|j<j>d|d%|&d||||||fScc}wcc}%}$}#w)&NrM)prefixdiskzThe current `device_map` had weights offloaded to the disk. Please provide an `offload_folder` for them. Alternatively, make sure you have `safetensors` installed if the model you are using offers the weights in this format.TrD)NN)rmodel_state_dictrrrCrrrrrrstate_dict_indexstate_dict_folderrrr2zLoading checkpoint shards)descrz z size mismatchz_ You may consider adding `ignore_mismatched_sizes=True` in the model `from_pretrained` method.z#Error(s) in loading state_dict for z: z(Some weights of the model checkpoint at z! were not used when initializing z: r*z9All model checkpoint weights were used when initializing z. zSome weights of z3 were not initialized from the model checkpoint at z and are newly initialized: zo You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.zAll the weights of z/ were initialized from the model checkpoint at zf. If your task is similar to the task the model of the checkpoint was trained on, you can already use z* for predictions without further training.rVz- z: found shape z in the checkpoint and z in the model instantiatedz= and are newly initialized because the shapes did not match: )#rerrhrupdate_missing_keys"_keys_to_ignore_on_load_unexpectedresearchr1ryrXr`r5r3tempfilemkdtemp functoolspartialr9r8rwr-tqdmr1rdrcshutilrmtreer3rrrMrrr )'rrrerrrrr rCrrrrrrrrr expected_keysrrpatrqrrexpanded_device_maprrrload_fn_mismatched_keys _error_msgs shard_files shard_file error_msgkeyshape1shape2mismatched_warnings' rBrz!ModelMixin._load_pretrained_models (!++--2245 C .[1AAB  #';;EE`a ) 4 QXYcQdN /1A;k) #33 4   $]);a)? }n = M!&u.>@QR /0 z?Q  J/I)+w !DU__E]E]D^^cdmcnop p  ! # NN:;X:YYz{~|H|H{IINPTPYPYZiPjOkNlm  KKSTYTcTcTlTlSmmpq r | q NN"5??#;#;"<=122N|n]nn   !Q & KK%eoo&>&>%?@123CCH??C[C[B\]--   ! #!%0?+VV^F83J6(Rlm"  NN"5??#;#;"<=123./0AA lO_mU___{#\bsP;P+P ctj|jj}|j Dcic]&\}}|j tj k(s$||(}}}t|j Dchc]%\}}|j tj k7s$|'c}}}t|jdhz }||fScc}}wcc}}w)NrA) inspect signaturerCr|rmdefault_emptyrrh)robjr|rqrrrequired_parametersoptional_parametersexpected_moduless rB_get_signature_keyszModelMixin._get_signature_keysfs&&s||4?? 0:0@0@0Bb1aiiSZSaSaFaq!tbb!1A1A1C"cAqyyT[TbTbGb1"cd2779:fXE!444 c"cs%C#C%C )C ct}|g}t|dkDr|jd}|jj|vrut |t rI|j%t|jjd|d|t|jz}|t|jz }t|dkDrt|S)a Get the modules of the model that should not be split when using device_map. We iterate through the modules to get the underlying `_no_split_modules`. Args: device_map (`str`): The device map value. Options are ["auto", "balanced", "balanced_low_0", "sequential"] Returns: `List[str]`: List of modules that should not be split rrKz does not support `device_map='z_'`. To implement support, the model class needs to implement the `_no_split_modules` attribute.) rrwrarrMrr_no_split_modulesryrr)rArr8modules_to_checkris rB_get_no_split_modulesz ModelMixin._get_no_split_modulesps E 6"#a'%))"-F((0AAfj1//7(%//8899XYcXdeZZ ->FD\D\@],]) D):$;; "#a'%&&rDc|jstd|jd|dtj d|jd|dt j }t j||S)a Change the default dtype and return the previous one. This is needed when wanting to instantiate the model under specific dtype. Args: dtype (`torch.dtype`): a floating dtype to set to. Returns: `torch.dtype`: the original `dtype` that can be used to restore `torch.set_default_dtype(dtype)` if it was modified. If it wasn't, returns `None`. Note `set_default_dtype` currently only works with floating-point types and asserts if for example, `torch.int64` is passed. So if a non-float `dtype` is passed this functions will throw an exception. zCan't instantiate z model under dtype=z' since it is not a floating point dtypezInstantiating z model under default dtype rW)rryrMrr rnget_default_dtyper)rrrs rBrz#ModelMixin._set_default_torch_dtypesw"&&$S\\N2EeWLst   nS\\N2MeWTUVW,,.  &rDct|S)z `torch.device`: The device on which the module is (assuming that all the module parameters are on the same device). )rrs rBrzModelMixin.devices $D))rDct|S)zw `torch.dtype`: The dtype of the module (assuming that all the module parameters have the same dtype). )rrs rBrzModelMixin.dtypes #4((rDonly_trainableexclude_embeddingsc t|dd}|rtrddl}n td|rh|j Dcgc]%\}}t |t js!|d'}}}|jDcgc] \}}||vs |} }}nt|j} g} | D]} | js|r|rt | j jrht| dr| j} n%t| dr| jj } nd } | j#| j%d z| z| j#| j%t'| Scc}}wcc}}w) a Get number of (trainable or non-embedding) parameters in the module. Args: only_trainable (`bool`, *optional*, defaults to `False`): Whether or not to return only the number of trainable parameters. exclude_embeddings (`bool`, *optional*, defaults to `False`): Whether or not to return only the number of non-embedding parameters. Returns: `int`: The number of parameters. Example: ```py from diffusers import UNet2DConditionModel model_id = "runwayml/stable-diffusion-v1-5" unet = UNet2DConditionModel.from_pretrained(model_id, subfolder="unet") unet.num_parameters(only_trainable=True) 859520964 ``` is_loaded_in_4bitFrNzbitsandbytes is not installed but it seems that the model has been loaded in 4bit precision, something went wrong make sure to install bitsandbytes with `pip install bitsandbytes`. You also need a GPU. z.weight element_size quant_storager2r)rr) bitsandbytesryrrr Embeddingrrr| requires_grad Params4bitrrCrDitemsizernumelsum) rAr?r@rBbnbr module_typeembedding_param_namesretotal_parameters total_numelr num_bytess rBnum_parameterszModelMixin.num_parameterssw0$D*=uE (** p :>:L:L:N%%6T;R\]hjljvjvRw4& % !%261F1F1H -dIDXmLm     $DOO$56  % 6E"".%E366;L;L)Mun5$)$6$6$8  8$)$7$7$@$@ $% &&u{{}q'89'DE&&u{{}5 6;5% s"E9"E9? E? E?c@t|jDcgc]#}|j|jz%c}}|rKt|j Dcgc]#}|j|jz%c}}||z}|Scc}wcc}w)a Get the memory footprint of a model. This will return the memory footprint of the current model in bytes. Useful to benchmark the memory footprint of the current model and design some tests. Solution inspired from the PyTorch discussions: https://discuss.pytorch.org/t/gpu-memory-that-model-uses/56822/2 Arguments: return_buffers (`bool`, *optional*, defaults to `True`): Whether to return the size of the buffer tensors in the computation of the memory footprint. Buffers are tensors that do not require gradients and not registered as parameters. E.g. mean and std in batch norm layers. Please see: https://discuss.pytorch.org/t/what-pytorch-means-by-buffers/120266/2 )rKr|nelementrCr})rAreturn_buffersrmembufmem_bufss rBget_memory_footprintzModelMixin.get_memory_footprints~HYZu5>>#e&8&8&::Z[ 4<<>ZCCLLNS-=-=-??Z[H.C [Zs (B (Brcd}|jD]>\}}t|dstjd|d|d||_||_d}@|s#t d|jjdy) NFrz Setting `gradient_checkpointing=z` for ''Tz The module z does not support gradient checkpointing. Please make sure to use a module that supports gradient checkpointing by creating a boolean attribute `gradient_checkpointing`.) rrrdebugrrryrrM)rArris_gradient_checkpointing_setrris rBrz&ModelMixin._set_gradient_checkpointing s).% ..0 5LD&v78 ?xwtfTUVW6Q306-04-  5-dnn5567~ -rDcPgfdd|D] }|d|vr|j|d||d<|d|vr|j|d||d<|d|vr|j|d||d<|d |vr|j|d ||d <|d |vr|j|d ||d <|d |vr|j|d ||d<|d|vr|j|d||d<|d|vs|j|d||d<|S)aK This function fix the state dict of the model to take into account some changes that were made in the model architecture: - deprecated attention blocks (happened before we introduced sharded checkpoint, so this is why we apply this method only when loading non sharded checkpoints for now) ct|dr|jrj||jD]\}}|dk(r|n|d|}||y)N_from_deprecated_attn_blockrMrW)rr`rnamed_children)rrisub_name sub_module deprecated_attention_block_pathsrecursive_find_attn_blocks rBrezJModelMixin._fix_state_dict_keys_on_load..recursive_find_attn_block$sev<=&BdBd077=(.(=(=(? @$*'+rz8$q 7K)(J? @rDrMz .query.weightz .to_q.weightz .query.biasz .to_q.biasz .key.weightz .to_k.weightz .key.biasz .to_k.biasz .value.weightz .to_v.weightz .value.biasz .to_v.biasz.proj_attn.weightz.to_out.0.weightz.proj_attn.biasz.to_out.0.bias)ra)rArerYrdres @@rBrz'ModelMixin._fix_state_dict_keys_on_loads,.( @ ""d+ 5 _D}%34>NNdV=CY4Z dV<01{#z12<..D6AU2V dV:./{#z14>NNdV;CW4X dV<01y!Z/2<..D6AS2T dV:./}%34>NNdV=CY4Z dV<01{#z12<..D6AU2V dV:./()Z78B$O`Ga8b dV#345':56@nnv_E]6^ dV>233 _4rDr?)rfN)TNTN10GBF) FFNTNNNNNNF)FF)T)NrMrNrOrPr config_name_automatically_saved_argsrrr8rrrrrCrrrpropertyboolrr r rrrrrrrrrrrrnrrrrrrr rrrr8r:rrXPathLikerr classmethodrrrrrrrrr rr rr rrr6r:rrRrYrrrr __classcell__rs@rBrrsK V',$)-& '+$!%1 )))$n4nn oRZI[ogko<;==$= /0SW9'+9=Eh=O9 9"I(9KI 0?C11)1();1 1""MxPXGY"Mei"MH@&+%8%8/3:>LP" S {{S   ,S 'uS#X7 S 'uT%((//-BC-G'HI S  S  S p(4u||E':).2" #.2= ||=  =  = 'sm =  = = = 'sm=  = ~!3S!3T!3F0,!%,0#'!%*0!Yc2;;./YY ) Y ! Y # Yc3hYYv -YHU3PRP[P[K[E\<]YlpYYx 588??   -!-4 588??  /+/+d'(B).).59"&3748^b-1<@7;6;#Z` Z`"#Y Z` (-S"++-='> Z` #Y Z`"&Z`#'Z`12Z` Z`c5;;./0Z`'tCy1Z`#sELL$sE#sELLBX T> t> `c> @&"5;;KaKaKlKl@H $1{1t1rDrc`eZdZdZeedeeee jfffd Z xZ S)LegacyModelMixinz A subclass of `ModelMixin` to resolve class mapping from legacy classes (like `Transformer2DModel`) to more pipeline-specific classes (like `DiTTransformer2DModel`). rc ddlm}|j}|jdd}|jdd}|jdd}|jdd}|jdd} |jd d} |jd d} |} td d d } |j | f|dd|||| | | | d |\}}}|||}||urt t|"|fi|S|j|fi|S)Nr2)_fetch_remapped_cls_from_configrrFrrrIrrrrrT) rrrrrrrIrrr) model_loading_utilsrrrrarrrrpr)rrrLrr kwargs_copyrrrrrIrrrrr_remapped_classrs rBrz LegacyModelMixin.from_pretrainedUs< Ikkm JJ{D1 $4e<**Y-!::&8$? 7D)::j$/JJ{D1 4 % " 's   !%#)-!    19E S )>J-1< 2>112O_S^_ _rD) rMrNrOrPrlrr rrrXrkrrmrns@rBrprpOsD /`HU3PRP[P[K[E\<]/`/`rDrp)trrr.rzrtrXrrr collectionsr contextlibrrrpathlibrtypingrr r r r r rrrrnrntorch.utils.checkpointhuggingface_hubrrrhuggingface_hub.utilsrrrtyping_extensionsrrMr quantizersrrquantizers.quantization_configrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-utils.hub_utilsr.r/r0utils.torch_utilsr1rsr3r4r5r6r7r8r9r:r< get_loggerrMrrrjrrRrSrTrUrVrWrXrYrZr[r\r]r^r_rrrrbaccelerate.utilsrcrdrrrrrrrrprQrDrBrs"  #0ZZZ VV6"C?& 3   --$   H %rzz12   wwWW**""ww..gg,,00ww..wwggnngg,,WW**ww..gg,,"D'"!%!&)K%EHHOO% %44#588??4#u{{4#n44&d.dN37`z7`rD