wi"ddlZddlmZmZmZmZddlZddlZddl m Z m Z ddl m Z mZddlmZmZmZejeZ d d ZGd d ee ZdS)N)ListOptionalTupleUnion) ConfigMixinregister_to_config) deprecatelogging)KarrasDiffusionSchedulersSchedulerMixinSchedulerOutput+?cosinec F|dkrd}n|dkrd}ntd|g}t|D]J}||z }|dz|z }|td||||z z |Kt j|tjS)a Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of (1-beta) over time from t = [0,1]. Contains a function alpha_bar that takes an argument t and transforms it to the cumulative product of (1-beta) up to that part of the diffusion process. Args: num_diffusion_timesteps (`int`): the number of betas to produce. max_beta (`float`): the maximum beta to use; use values lower than 1 to prevent singularities. alpha_transform_type (`str`, *optional*, default to `cosine`): the type of noise schedule for alpha_bar. Choose from `cosine` or `exp` Returns: betas (`np.ndarray`): the betas used by the scheduler to step the model outputs rc\tj|dzdz tjzdz dzS)NgMb?gT㥛 ?r)mathcospits /root/.openclaw/workspace/chatterbox_venv_py311/lib/python3.11/site-packages/diffusers/schedulers/scheduling_dpmsolver_singlestep.py alpha_bar_fnz)betas_for_alpha_bar..alpha_bar_fn9s,8QY%/$'9A=>>!C Cexpc0tj|dzS)Ng()rrrs rrz)betas_for_alpha_bar..alpha_bar_fn>s8AI&& &rz"Unsupported alpha_transform_type: r dtype) ValueErrorrangeappendmintorchtensorfloat32)num_diffusion_timestepsmax_betaalpha_transform_typerbetasit1t2s rbetas_for_alpha_barr. s.x'' D D D D  & & ' ' ' 'T>RTTUUU E * + +MM ( (!e. . S\\"-- R0@0@@@(KKLLLL <U] 3 3 33rc%eZdZdZdeDZdZedddddd d d d d ddd d ded dfde dedede de e j de de dededede de dede ed e e d!ed"e e f"d#Zd$e d%ee fd&Zed'Zed(ZdJd*e fd+Z dKd$e d,ee ejfd-e ee fd.Zd/ejd%ejfd0Zd1Zd2Zd3ejd%ejfd4Zdd5d6ejd/ejd%ejfd7Zdd5d6ejd/ejd%ejfd8Z dd5d9eejd/ejd%ejfd:Z!dd5d9eejd/ejd%ejfd;Z"ddd<d9eejd/ejd=e d%ejfd>Z#dLd?Z$d@Z% dMd6ejdBe d/ejdCed%ee&e'ff dDZ(d/ejd%ejfdEZ)dFejdGejd-ej*d%ejfdHZ+dIZ,dS)NDPMSolverSinglestepScheduleru `DPMSolverSinglestepScheduler` is a fast dedicated high-order solver for diffusion ODEs. This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic methods the library implements for all schedulers such as loading and saving. Args: num_train_timesteps (`int`, defaults to 1000): The number of diffusion steps to train the model. beta_start (`float`, defaults to 0.0001): The starting `beta` value of inference. beta_end (`float`, defaults to 0.02): The final `beta` value. beta_schedule (`str`, defaults to `"linear"`): The beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from `linear`, `scaled_linear`, or `squaredcos_cap_v2`. trained_betas (`np.ndarray`, *optional*): Pass an array of betas directly to the constructor to bypass `beta_start` and `beta_end`. solver_order (`int`, defaults to 2): The DPMSolver order which can be `1` or `2` or `3`. It is recommended to use `solver_order=2` for guided sampling, and `solver_order=3` for unconditional sampling. prediction_type (`str`, defaults to `epsilon`, *optional*): Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process), `sample` (directly predicts the noisy sample`) or `v_prediction` (see section 2.4 of [Imagen Video](https://imagen.research.google/video/paper.pdf) paper). thresholding (`bool`, defaults to `False`): Whether to use the "dynamic thresholding" method. This is unsuitable for latent-space diffusion models such as Stable Diffusion. dynamic_thresholding_ratio (`float`, defaults to 0.995): The ratio for the dynamic thresholding method. Valid only when `thresholding=True`. sample_max_value (`float`, defaults to 1.0): The threshold value for dynamic thresholding. Valid only when `thresholding=True` and `algorithm_type="dpmsolver++"`. algorithm_type (`str`, defaults to `dpmsolver++`): Algorithm type for the solver; can be `dpmsolver` or `dpmsolver++`. The `dpmsolver` type implements the algorithms in the [DPMSolver](https://huggingface.co/papers/2206.00927) paper, and the `dpmsolver++` type implements the algorithms in the [DPMSolver++](https://huggingface.co/papers/2211.01095) paper. It is recommended to use `dpmsolver++` or `sde-dpmsolver++` with `solver_order=2` for guided sampling like in Stable Diffusion. solver_type (`str`, defaults to `midpoint`): Solver type for the second-order solver; can be `midpoint` or `heun`. The solver type slightly affects the sample quality, especially for a small number of steps. It is recommended to use `midpoint` solvers. lower_order_final (`bool`, defaults to `True`): Whether to use lower-order solvers in the final steps. Only valid for < 15 inference steps. This can stabilize the sampling of DPMSolver for steps < 15, especially for steps <= 10. use_karras_sigmas (`bool`, *optional*, defaults to `False`): Whether to use Karras sigmas for step sizes in the noise schedule during the sampling process. If `True`, the sigmas are determined according to a sequence of noise levels {σi}. final_sigmas_type (`str`, *optional*, defaults to `"zero"`): The final `sigma` value for the noise schedule during the sampling process. If `"sigma_min"`, the final sigma is the same as the last sigma in the training schedule. If `zero`, the final sigma is set to 0. lambda_min_clipped (`float`, defaults to `-inf`): Clipping threshold for the minimum value of `lambda(t)` for numerical stability. This is critical for the cosine (`squaredcos_cap_v2`) noise schedule. variance_type (`str`, *optional*): Set to "learned" or "learned_range" for diffusion models that predict variance. If set, the model's output contains the predicted Gaussian variance. cg|] }|j S)name).0es r z'DPMSolverSinglestepScheduler.s>>>qAF>>>rr ig-C6?g{Gz?linearNrepsilonFgףp= ?? dpmsolver++midpointzeroinfnum_train_timesteps beta_startbeta_end beta_schedule trained_betas solver_orderprediction_type thresholdingdynamic_thresholding_ratiosample_max_valuealgorithm_type solver_typelower_order_finaluse_karras_sigmasfinal_sigmas_typelambda_min_clipped variance_typec| dkrd}tdd||&tj|tj|_n|dkr(tj|||tj|_nk|dkr1tj|dz|dz|tjd z|_n4|d krt ||_nt|d |jd |jz |_ tj |j d |_ tj |j |_ tj d|j z |_tj|j tj|jz |_d|j z |j z dz|_d |_| dvr6| dkr|dnt| d |j| dvr4| dvr|dnt| d |j| dkr|dkrt)d|d| dd|_t-jd |dz |t,jddd}tj||_dg|z|_d|_|||_d|_d|_|j d|_dS)N dpmsolverzalgorithm_type `dpmsolver` is deprecated and will be removed in a future version. Choose from `dpmsolver++` or `sde-dpmsolver++` insteadzalgorithm_types=dpmsolver1.0.0rr7 scaled_linear?rsquaredcos_cap_v2z is not implemented for r9rdimr )rPr:deisr:)rH)r;heun)logrhobh1bh2r;)rIr<z`final_sigmas_type` z' is not supported for `algorithm_type` z%. Please chooose `sigma_min` instead.cpu)!r r$r%r&r*linspacer.NotImplementedError __class__alphascumprodalphas_cumprodsqrtalpha_tsigma_tloglambda_tsigmasinit_noise_sigmar r num_inference_stepsnpcopy from_numpy timesteps model_outputssampleget_order_list order_list _step_index _begin_indexto)selfr>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNdeprecation_messageros r__init__z%DPMSolverSinglestepScheduler.__init__s4* [ ( (#m  17QY^YfgggDJJ o - - C3H[chcpqqquvvDJJ 1 1 1,-@AADJJ%&`&`PTP^&`&`aa aDJ& #mDKQ???z$"566 z!d&9"9::  $,//%)DL2I2II D//43FF3N !$ != = =''''}'EEEE)^*e*eUYUc*e*efff 2 2 2666''J'????)[*b*bRVR`*b*bccc ] * */@F/J/JW'8WWaoWWW  $( K#6#: 3 is not supported by this schedulerr)r rr|r r)configrCr rJ)rwrkstepsorderorderss rrrz+DPMSolverSinglestepScheduler.get_order_listsu$ ( 199KLL L ; ( %zz19>>&YY%1*q.9QFBaSHFFQY!^^&YY%1*5;FF&YY%1*5A>FF!19>>VuzA~6!Q?FFVuz2aS8FF!uzz"eqj1!Q5A:.!u rc|jS)zg The index counter for current timestep. It will increase 1 after each scheduler step. )rtrws r step_indexz'DPMSolverSinglestepScheduler.step_indexs rc|jS)zq The index for the first timestep. It should be set from pipeline with `set_begin_index` method. rurs r begin_indexz(DPMSolverSinglestepScheduler.begin_indexs   rrrc||_dS)z Sets the begin index for the scheduler. This function should be run from pipeline before the inference. Args: begin_index (`int`): The begin index for the scheduler. Nr)rwrs rset_begin_indexz,DPMSolverSinglestepScheduler.set_begin_index s(rdeviceroc Z||td||td|jjrtd|pt|}|_|2t j|t j}ntj tj j dgjj }t jdjjdz |z |dzdddddt j}t jdjz jz dz}jjrt j|t j |}||}t jfd |D}n6t j|t jdt||}jjd kr"djdz jdz dz}n/jjd krd}ntd jjt j||ggt j}tj|| _tj||tj_dgjjz_d_ jj!sC|jjzdkr0tD#d$djj!s@jjd kr0tD#d$d%|_&d_'d_(jd_dS)a Sets the discrete timesteps used for the diffusion chain (to be run before inference). Args: num_inference_steps (`int`): The number of diffusion steps used when generating samples with a pre-trained model. device (`str` or `torch.device`, *optional*): The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. timesteps (`List[int]`, *optional*): Custom timesteps used to support arbitrary spacing between timesteps. If `None`, then the default timestep spacing strategy of equal spacing between timesteps schedule is used. If `timesteps` is passed, `num_inference_steps` must be `None`. Nz?Must pass exactly one of `num_inference_steps` or `timesteps`.zDPMSolverSinglestepScheduler.set_timesteps..Ds)!Z!Z!Z%$"2"25*"E"E!Z!Z!Zr sigma_minr<zC `final_sigmas_type` must be one of `sigma_min` or `zero`, but got )rrrzChanging scheduler {self.config} to have `lower_order_final` set to True to handle uneven amount of inference steps. Please make sure to always use an even number of `num_inference steps when using `lower_order_final=False`.T)rJz `last_sigmas_type='zero'` is not supported for `lower_order_final=False`. Changing scheduler {self.config} to have `lower_order_final` set to True.r]))r r}rKlenrkrlarrayastypeint64r$ searchsortedfliprhrMr^r>roundrmrcrg_convert_to_karrasinterparangerL concatenater&rnrvrirorCrprqrJloggerwarningr rrrsrtru)rwrkrro clipped_idxri sigma_lastrs` @r set_timestepsz*DPMSolverSinglestepScheduler.set_timestepss&  &9+<^__ _  *y/D^__ _  T[%B [\\ \1CS^^#6  ++2228<B[PRehiRijj2"s$!! A 33t7JJsRSS ; ( MJWV__))++F,,vSf,ggF!Z!Z!Z!Z!ZSY!Z!Z!Z[[aaccIIYy")As6{{*C*CVLLF ; (K 7 7t21559LQ9OOTWWJJ [ *f 4 4JJuVZVaVsuu * 677>>rzJJ&v..111@@ ))4477vU[7YY"Vdk&>> {, <1Dt{G_1_cd1d1d NNs     # #d # ; ; ;{, <1NRX1X1X NNg     # #d # ; ; ;--.ABB  knnU++ rrqc,|j}|j^}}}|tjtjfvr|}|||tj|z}| }tj ||j j d}tj |d|j j}|d}tj || ||z }|j||g|R}||}|S)as "Dynamic thresholding: At each sampling step we set s to a certain percentile absolute pixel value in xt0 (the prediction of x_0 at timestep t), and if s > 1, then we threshold xt0 to the range [-s, s] and then divide by s. Dynamic thresholding pushes saturated pixels (those near -1 and 1) inwards, thereby actively preventing pixels from saturation at each step. We find that dynamic thresholding results in significantly better photorealism as well as better image-text alignment, especially when using very large guidance weights." https://arxiv.org/abs/2205.11487 r rU)r#max)rshaper$r&float64floatreshaperlprodabsquantiler}rFclamprG unsqueezerv)rwrqr batch_sizechannelsremaining_dims abs_sampless r_threshold_samplez.DPMSolverSinglestepScheduler._threshold_samplels 06 - H~  6 6 6\\^^F Hrw~7N7N,NOOZZ\\ N:t{'MST U U U K 1$+6    KKNNVaR++a/ HF~FFF5!! rctjtj|d}||ddtjfz }tj|dkdd|jddz }|dz}||}||}||z ||z z } tj| dd} d| z |z| |zz} | |j} | S)Ng|=r)axisr)rr ) rlrgmaximumnewaxiscumsumargmaxcliprr) rwrr log_sigmadistslow_idxhigh_idxlowhighwrs rrz(DPMSolverSinglestepScheduler._sigma_to_tsF2:eU3344 Jqqq"*}55)UaZq11188a8@@EE*JZ[\J]`aJaEbbQ;!(#9_t , GAq!  Ug H , IIek " "rc0d|dzdzdzz }||z}||fS)Nr rrSr2)rwrrerfs r_sigma_to_alpha_sigma_tz4DPMSolverSinglestepScheduler._sigma_to_alpha_sigma_ts-q1 ,-'/rrczt|jdr |jj}nd}t|jdr |jj}nd}||n|d}||n|d}d}t jdd|}|d|z z}|d|z z}||||z zz|z} | S)z6Constructs the noise schedule of Karras et al. (2022).rN sigma_maxr\rg@r )hasattrr}rritemrlr^) rwrrkrrrhoramp min_inv_rho max_inv_rhoris rrz/DPMSolverSinglestepScheduler._convert_to_karrass 4; , ,  -III 4; , ,  -III!*!6IIIbM The algorithm and model type are decoupled. You can use either DPMSolver or DPMSolver++ for both noise prediction and data prediction models. Args: model_output (`torch.Tensor`): The direct output from the learned diffusion model. sample (`torch.Tensor`): A current instance of a sample created by the diffusion process. Returns: `torch.Tensor`: The converted model output. rtimestepNr z/missing `sample` as a required keyward argumentrorQPassing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`r:r8) learned_ranger|rq v_predictionzprediction_type given as z\ must be one of `epsilon`, `sample`, or `v_prediction` for the DPMSolverSinglestepScheduler.rP) rpopr r r}rHrDrNrirrrEr) rwrrqargskwargsrrrerfx0_predr8s rconvert_model_outputz1DPMSolverSinglestepScheduler.convert_model_outputs:"$ii!mm477J1M1M >4yy1}}a !RSSS   Z    ; % 6 6{*i77;,0AAA#/2A2#6L DO4#'#?#?#F#F !Gl$::gE,88&,>> DO4#'#?#?#F#F !F*W|-CC L 0KLLL {' :0099N [ '; 6 6{*i77;,0AAA#/2A2#6L##,88 DO4#'#?#?#F#F !Gl$::gE,>> DO4#'#?#?#F#F !L07V3CC L 0KLLL#7 6rct|dkr|dn|dd}t|dkr|dn|dd}|+t|dkr |d}ntd|tdd d |tdd d |j|jdz|j|j}}||\} }||\} }tj| tj|z } tj| tj|z } | | z } |j j d kr(||z |z| tj | d z z|zz }n6|j j dkr&| | z |z|tj | d z z|zz }|S)az One step for the first-order DPMSolver (equivalent to DDIM). Args: model_output (`torch.Tensor`): The direct output from the learned diffusion model. timestep (`int`): The current discrete timestep in the diffusion chain. prev_timestep (`int`): The previous discrete timestep in the diffusion chain. sample (`torch.Tensor`): A current instance of a sample created by the diffusion process. Returns: `torch.Tensor`: The sample tensor at the previous timestep. rrNr prev_timestepr0 missing `sample` as a required keyward argumentrorQrPassing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`r:r9rP) rrr r rirrr$rgr}rHr)rwrrqrrrrrfsigma_srealpha_srhlambda_shx_ts rdpm_solver_first_order_updatez:DPMSolverSinglestepScheduler.dpm_solver_first_order_updates0"$ii!mm477J1M1M#&t99q==QfjjRV6W6W >4yy1}}a !STTT   Z     $ ^     ;t':;T[=Y77@@77@@9W%% '(:(::9W%% '(:(:: x  ; % 6 6W$.'UYr]]S=P2QUa1aaCC [ '; 6 6W$.'UYq\\C=O2PT`1``C rmodel_output_listct|dkr|dn|dd}t|dkr|dn|dd}|+t|dkr |d}ntd|tddd |tddd |j|jdz|j|j|j|jdz } }}||\} }||\} }|| \} } tj| tj|z } tj| tj|z }tj| tj| z }|d |d }}| |z ||z }}||z }|d |z ||z z}}|j j dkr|j j dkrK|| z |z| tj | d z z|zz d| tj | d z zz|zz }n|j j dkrL|| z |z| tj | d z z|zz | tj | d z |z d zz|zz}n|j j dkr|j j dkrH| | z |z|tj |d z z|zz d|tj |d z zz|zz }nZ|j j dkrJ| | z |z|tj |d z z|zz |tj |d z |z d z z|zz }|S)a One step for the second-order singlestep DPMSolver that computes the solution at time `prev_timestep` from the time `timestep_list[-2]`. Args: model_output_list (`List[torch.Tensor]`): The direct outputs from learned diffusion model at current and latter timesteps. timestep (`int`): The current and latter discrete timestep in the diffusion chain. prev_timestep (`int`): The previous discrete timestep in the diffusion chain. sample (`torch.Tensor`): A current instance of a sample created by the diffusion process. Returns: `torch.Tensor`: The sample tensor at the previous timestep. r timestep_listNr rrrrQPassing `timestep_list` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`rr\r9r:r;rSrXrP rrr r rirrr$rgr}rHrIr)rwrrqrrrrrfsigma_s0sigma_s1realpha_s0alpha_s1rh lambda_s0 lambda_s1m0m1rh_0r0D0D1rs r)singlestep_dpm_solver_second_order_updatezFDPMSolverSinglestepScheduler.singlestep_dpm_solver_second_order_updateWs2$'t99q==QfjjRV6W6W #&t99q==QfjjRV6W6W >4yy1}}a !STTT  $ ^     $ ^    K!+ , K ( K!+ ,$  77@@!99(CC(!99(CC(9W%% '(:(::Ih''%)H*=*== Ih''%)H*=*== "2&(9"(=BI%y9'<3 1WcBh27+B ; % 6 6{&*44x'61%)QB--#"56"<=W 1" (;<=BC (F22x'61%)QB--#"56"<=59aR==3#6!";c"ABbHI [ '; 6 6{&*44x'61%)A,,"45;<W ! s(:;4yy1}}a !RSSS  $ ^     $ ^    K!+ , K ( K!+ , K!+ , 1 -8X 77@@!99(CC(!99(CC(!99(CC(9W%% '(:(::Ih''%)H*=*== Ih''%)H*=*== Ih''%)H*=*== &r*,=b,ACTUWCXB*I ,A9yCX3q#'B Bh27+cBh27-Cd4i"t)#R 0 D4K BG , ; % 6 6{&*44x'61%)QB--#"56"<=59aR==3#6!";c"ABdJK (F22x'61%)QB--#"56"<=59aR==3#6!";c"ABbHI59aR==3#6#:ad"BS"HIROP [ '; 6 6{&*44x'61%)A,,"45;<59Q<<##5":S"@ATIJ (F22x'61%)A,,"45;<59Q<<##5":S"@ARGH59Q<<##5#9QT"AC"GHBNO  rrqrrct|dkr|dn|dd}t|dkr|dn|dd}|+t|dkr |d}ntd|+t|dkr |d}ntd |tdd d |tdd d |dkr||d |S|dkr|||S|dkr|||Std|)a One step for the singlestep DPMSolver. Args: model_output_list (`List[torch.Tensor]`): The direct outputs from learned diffusion model at current and latter timesteps. timestep (`int`): The current and latter discrete timestep in the diffusion chain. prev_timestep (`int`): The previous discrete timestep in the diffusion chain. sample (`torch.Tensor`): A current instance of a sample created by diffusion process. order (`int`): The solver order at this step. Returns: `torch.Tensor`: The sample tensor at the previous timestep. rrNr rrrr|z/ missing `order` as a required keyward argumentrQrrr\rzOrder must be 1, 2, 3, got )rrr r rrr)rwrrqrrrrrs rsinglestep_dpm_solver_updatez9DPMSolverSinglestepScheduler.singlestep_dpm_solver_updates6$'t99q==QfjjRV6W6W #&t99q==QfjjRV6W6W >4yy1}}a !RSSS =4yy1}}Q !RSSS  $ ^     $ ^    A::556G6KTZ5[[ [ aZZAABS\bAcc c aZZ@@AR[a@bb bB5BBCC Crc.||j}||k}t|dkrt|jdz }nHt|dkr|d}n|d}|S)Nrr )rononzerorr)rwrschedule_timestepsindex_candidatesrs rindex_for_timestepz/DPMSolverSinglestepScheduler.index_for_timestep\s  %!% .(:CCEE  A % %T^,,q0JJ ! " "Q & &)!,1133JJ)!,1133Jrc|jUt|tjr||jj}|||_dS|j |_dS)zF Initialize the step_index counter for the scheduler. N) r isinstancer$Tensorrvrorrrtru)rwrs r_init_step_indexz-DPMSolverSinglestepScheduler._init_step_indexpsd   #(EL11 >#;;t~'<==#66x@@D   #0D   rTr return_dictc$|jtd|j|||||}t |jjdz D]}|j|dz|j|<||jd<|j |j}|j| |dz}|j| |dkr||_ | |j|j |}|xj dz c_ |s|fSt|S)a Predict the sample from the previous timestep by reversing the SDE. This function propagates the sample with the singlestep DPMSolver. Args: model_output (`torch.Tensor`): The direct output from learned diffusion model. timestep (`int`): The current discrete timestep in the diffusion chain. sample (`torch.Tensor`): A current instance of a sample created by the diffusion process. return_dict (`bool`): Whether or not to return a [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`. Returns: [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`: If return_dict is `True`, [`~schedulers.scheduling_utils.SchedulerOutput`] is returned, otherwise a tuple is returned where the first element is the sample tensor. NzaNumber of inference steps is 'None', you need to run 'set_timesteps' after creating the schedulerrr r\r) prev_sample)rkr rr rr!r}rCrprsrqrrtr)rwrrrqr r+rrs rstepz!DPMSolverSinglestepScheduler.step|sH6  # +s  ? "  ! !( + + +00f0MM t{/!344 > >A$($6q1u$=D q ! !!-20 %(0 QJE %(0 A:: DK778JSWS^fk7ll  A "> !;7777rc|S)a? Ensures interchangeability with schedulers that need to scale the denoising model input depending on the current timestep. Args: sample (`torch.Tensor`): The input sample. Returns: `torch.Tensor`: A scaled input sample. r2)rwrqrrs rscale_model_inputz.DPMSolverSinglestepScheduler.scale_model_inputs  roriginal_samplesnoisec j|j|j}|jjdkrft j|rRj|jt j ||jt j}n9j|j ||j}j  fd|D}n4j j g|j dz}nj g|j dz}|| }t|j t|j kr?|d}t|j t|j k?|\}}||z||zz} | S)Nrmpsrc<g|]}|Sr2)r)r4rrrws rr6z:DPMSolverSinglestepScheduler.add_noise..s*^^^qD33A7IJJ^^^rrr\)rirvrrtyper$is_floating_pointror&rrrflattenrrr) rwrrrori step_indicesrrerf noisy_samplesrs ` @r add_noisez&DPMSolverSinglestepScheduler.add_noises'7'>FVF\]]  " '5 0 0U5LY5W5W 0!%!2!23C3JRWR_!2!`!` ! %5%>"22Wu_D rc|jjSN)r}r>rs r__len__z$DPMSolverSinglestepScheduler.__len__s {..r)r)NNNr)T)-__name__ __module__ __qualname____doc__r _compatiblesrr rintstrrrlndarrayboolryrrrpropertyrrrrr$rrr rrrrrrrrrrr rrrr IntTensorrr r2rrr0r0LsN99v?>$=>>>L E$("%.2(",1"%+%"',1+1%*U5\\M'+%J,J, J,J, J,  J,   + J,J,J,J,%*J, J,J,J, J,$D>J, $C=!J,""#J,$ }%J,J,J,J,X"#"$s)""""H  X !!X!((3(((($(+/)- T,T, T,c5<'(T,DI& T,T,T,T,n D0   ELRWR^: $ WWWlW W  WWWWz $ 666l6 6  6666x $ \\\ -\ \  \\\\D $ fff -f f  ffffX $ <D<D<D -<D <D  <D <D<D<D<D~( 1 1 1"! ;8;8l;8;8 ;8  ;8 % & ;8;8;8;8z  %,     , | ?      D/////rr0)rr)rtypingrrrrnumpyrlr$configuration_utilsrr utilsr r scheduling_utilsr rr get_loggerr!rr.r0r2rrr2s" //////////// AAAAAAAA&&&&&&&&XXXXXXXXXX  H % % !)4)4)4)4X`/`/`/`/`/>;`/`/`/`/`/r