3j}FSSKJr SSKrSSKJrJr SSKrSSKJr SSK J r SSK J r SSK JrJrJr \(aSS KJr S r\"\5r"S S \ \5r"S S\5rSSjrg)) annotationsN) TYPE_CHECKINGAny)validate_hf_hub_args)Self) ConfigMixin) BaseOutputPushToHubMixin get_logger BlockStatezguider_config.jsonc^\rSrSrSr\rSrSrSSSjjr Sr Sr Sr SS jr SS jrSU4S jjrSS jrSS jrS SjrS!SjrS"SjrS#Sjr\S$Sj5r\S$Sj5r\S%Sj5r\S&Sj5r\S'Sj5r\\S(S)Sjj55rS*S+SjjrSr U=r!$), BaseGuidance&zGBase class providing the skeleton for implementing guidance techniques.N__guidance_identifier__c[RS5 XlX lSUlSUlSUlSUlSUlX0l SUs=::aS:dO [SUS35eXs=::aS::dO [SUSUS35eURb[UR[5(d [S 5eg) NzGuiders are currently an experimental feature under active development. The API is subject to breaking changes in future releases.r?z4Expected `start` to be between 0.0 and 1.0, but got .zExpected `stop` to be between z and 1.0, but got z\`_input_predictions` must be a list of required prediction names for the guidance technique.)loggerwarning_start_stop_step_num_inference_steps _timestep_count_prepared _input_fields_enabled ValueError_input_predictions isinstancelist)selfstartstopenableds X/home/wildlama/miniconda3/lib/python3.13/site-packages/diffusers/guiders/guider_utils.py__init__BaseGuidance.__init__-s Q    )-!+/ ?C u"s"STYSZZ[\] ]$$=eWDVW[V\\]^_ _  " " **T=T=TVZ2[2[n 3\c PURR"UR40UD6$)ax Creates a copy of this guider instance, optionally with modified configuration parameters. Args: **kwargs: Configuration parameters to override in the new instance. If no kwargs are provided, returns an exact copy with the same configuration. Returns: A new guider instance with the same (or updated) configuration. Example: ```python # Create a CFG guider guider = ClassifierFreeGuidance(guidance_scale=3.5) # Create an exact copy same_guider = guider.new() # Create a copy with different start step, keeping other config the same new_guider = guider.new(guidance_scale=5) ``` ) __class__ from_configconfig)r%kwargss r)newBaseGuidance.newEs".~~))$++@@@r,cSUlg)NFr r%s r)disableBaseGuidance.disable^s  r,cSUlg)NTr5r6s r)enableBaseGuidance.enableas  r,c6XlX lX0lSUlg)Nr)rrrr)r%stepnum_inference_stepstimesteps r) set_stateBaseGuidance.set_stateds $7!! r,cURURURURURUR S.nU$)a Returns the current state of the guidance technique as a dictionary. The state variables will be included in the __repr__ method. Returns: `dict[str, Any]`: A dictionary containing the current state variables including: - step: Current inference step - num_inference_steps: Total number of inference steps - timestep: Current timestep tensor - count_prepared: Number of times prepare_models has been called - enabled: Whether the guidance is enabled - num_conditions: Number of conditions )r=r>r?count_preparedr(num_conditions)rrrrr rD)r%states r) get_stateBaseGuidance.get_statejsBJJ#'#<#<"22}}"11   r,c >[T U]5nUR5n/nUR5HoupE[ U5nSU;aBUR S5nUSS-SR USSVs/sHnSU-PM sn5-nURSUSU35 Mq SR U5n USU 3$s snf) za Returns a string representation of the guidance object including both config and current state.  rNz z z: z State: )super__repr__rFitemsstrsplitjoinappend) r%str_reprrE state_lineskvv_strv_linesline state_strr.s r)rLBaseGuidance.__repr__s 7#%  KKMDAFEu}++d+ T)DIIQXYZY[Q\6]Q\v}Q\6],^^   A3b0 1"IIk* :i[11 7^s2B= c.U=RS- slg)z Prepares the models for the guidance technique on a given batch of data. This method should be overridden in subclasses to implement specific model preparation logic. rJN)rr%denoisers r)prepare_modelsBaseGuidance.prepare_modelss !r,cg)a  Cleans up the models for the guidance technique after a given batch of data. This method should be overridden in subclasses to implement specific model cleanup logic. It is useful for removing any hooks or other stateful modifications made during `prepare_models`. Nr\s r)cleanup_modelsBaseGuidance.cleanup_modelss r,c[S5e)Nz?BaseGuidance::prepare_inputs must be implemented in subclasses.NotImplementedError)r%datas r)prepare_inputsBaseGuidance.prepare_inputss!"cddr,c[S5e)NzPBaseGuidance::prepare_inputs_from_block_state must be implemented in subclasses.re)r%rg input_fieldss r)prepare_inputs_from_block_state,BaseGuidance.prepare_inputs_from_block_states""tuur,cP[SU55(d [S5e[U5UR:wa%[SURS[U5S35eUVs0sH#n[ X R 5UR _M% nnUR"S0UD6$s snf)Nc3:# UHn[US5v M g7f) noise_predN)hasattr).0ds r) (BaseGuidance.__call__..s:T71l++Tsz1Expected all data to have `noise_pred` attribute.z Expected z data items, but got z. Please check the input data.ra)allr!lenrDgetattr_identifier_keyrpforward)r%rgrsforward_inputss r)__call__BaseGuidance.__call__s:T:::PQ Q t9++ +D//00Ec$i[Pno SWWRVQ'!%9%9:ALLHRVW||-n--Xs%*B#c[S5e)Nz8BaseGuidance::forward must be implemented in subclasses.re)r%argsr1s r)rzBaseGuidance.forwards!"\]]r,c[S5e)Nz?BaseGuidance::is_conditional must be implemented in subclasses.rer6s r)is_conditionalBaseGuidance.is_conditional!"cddr,c$UR(+$)N)rr6s r)is_unconditionalBaseGuidance.is_unconditionals&&&&r,c[S5e)Nz?BaseGuidance::num_conditions must be implemented in subclasses.rer6s r)rDBaseGuidance.num_conditionsrr,ctSSKJn 0nUR5H]upg[U[R 5(aXuU'M+[U[ 5(aXrXV'MH[S[U535e X5UR'U"S0UD6$![a [RSUS35 Mf=f)7 Prepares a batch of data for the guidance technique. This method is used in the `prepare_inputs` method of the `BaseGuidance` class. It prepares the batch based on the provided tuple index. Args: input_fields (`dict[str, str | tuple[str, str]]`): A dictionary where the keys are the names of the fields that will be used to store the data once it is prepared with `prepare_inputs`. The values can be either a string or a tuple of length 2, which is used to look up the required data provided for preparation. If a string is provided, it will be used as the conditional data (or unconditional if used with a guidance method that requires it). If a tuple of length 2 is provided, the first element must be the conditional data identifier and the second element must be the unconditional data identifier or None. data (`BlockState`): The input data to be prepared. tuple_index (`int`): The index to use when accessing input fields that are tuples. Returns: `BlockState`: The prepared batch of data. rr zInvalid value type: "`data` does not have attribute(s) , skipping.ra) "modular_pipelines.modular_pipelinerrMr#torchTensortupler!typerdebugry)clsrg tuple_index identifierr data_batchkeyvalues r)_prepare_batchBaseGuidance._prepare_batchs6 D **,JC VeU\\22&+sOu--&+&8JO$';DK=%IJJ'+53&&''J'' V A% TU Vs#BB!B#B76B7c\SSKJn 0nUR5HQupx[U[5(a[ X(5Xg'M*[U[ 5(a[ X(U5Xg'MQMS XFUR'U"S0UD6$![a [RSUS35 Mf=f)rrr rrra) rrrMr#rNrxrAttributeErrorrrry) rrkrgrrrrrrs r)_prepare_batch_from_block_state,BaseGuidance._prepare_batch_from_block_states8 D &,,.JC VeS))&-d&:JOu--&-d+4F&GJO/+53&&''J''" V A% TU Vs"B%B#B+*B+c `UR"SUUSSS.UD6upTnUR"U4SU0UD6$)a Instantiate a guider from a pre-defined JSON configuration file in a local directory or Hub repository. 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 guider configuration saved with [`~BaseGuidance.save_pretrained`]. subfolder (`str`, *optional*): The subfolder location of a model file within a larger model repository on the Hub or locally. return_unused_kwargs (`bool`, *optional*, defaults to `False`): Whether kwargs that are not consumed by the Python class should be returned or not. cache_dir (`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. 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. > [!TIP] > 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. T)pretrained_model_name_or_path subfolderreturn_unused_kwargsreturn_commit_hashrra) load_configr/)rrrrr1r0 commit_hashs r)from_pretrainedBaseGuidance.from_pretrained!sPh'*oo' *G!%# '  ' # v[rr?ztorch.LongTensorreturnNone)rzdict[str, Any])rrN)r]ztorch.nn.Modulerr)rg 'BlockState'rlist['BlockState'])rgrrk dict[str, str | tuple[str, str]]rr)rgrrr)rr)rr)rr)rgz,dict[str, tuple[torch.Tensor, torch.Tensor]]rrrrNrr) rkrrgrrrrrNrr)NNF)rzstr | os.PathLike | Nonerz str | Nonerr)F)rzstr | os.PathLikerr)"__name__ __module__ __qualname____firstlineno____doc__GUIDER_CONFIG_NAME config_namer"ryr*r2r7r:r@rFrLr^rbrhrlr|rzpropertyrrrD classmethodrrrrr__static_attributes__ __classcell__)r.s@r)rr&sR$K/O0A2! ,22" ev v0Pv v .^ee''ee((:(((( ((  ((((T*(6*(*( *(  *(  *(*(XCG $" 9\'?9\9\  9\9\v[[r,rc4\rSrSr%S\S'S\S'S\S'Srg) GuiderOutputipz torch.Tensorpredztorch.Tensor | None pred_cond pred_uncondraN)rrrr__annotations__rrar,r)rrps ""$$r,rcUR[[SUR55SS9nUR[[SUR55SS9nXU- -nX%-SU- U--nU$)a Rescales `noise_cfg` tensor based on `guidance_rescale` to improve image quality and fix overexposure. Based on Section 3.4 from [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). Args: noise_cfg (`torch.Tensor`): The predicted noise tensor for the guided diffusion process. noise_pred_text (`torch.Tensor`): The predicted noise tensor for the text-guided diffusion process. guidance_rescale (`float`, *optional*, defaults to 0.0): A rescale factor applied to the noise predictions. Returns: noise_cfg (`torch.Tensor`): The rescaled noise prediction tensor. rJT)dimkeepdim)stdr$rangendim) noise_cfgnoise_pred_textguidance_rescalestd_textstd_cfgnoise_pred_rescaleds r)rescale_noise_cfgrvs{ ""tE!_5I5I,J'KUY"ZHmmU1inn%= >mMG#''9: 6!>N:NR[9[[I r,)r) __future__rostypingrrrhuggingface_hub.utilsrtyping_extensionsrconfiguration_utilsr utilsr r r rrrrrrrrrar,r)rsb# % 6"-::?* H G[;G[T %:% r,